home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / dsp / 56ktools / dspkgctr.z / dspkgctr / gcc / cccp.c < prev    next >
C/C++ Source or Header  |  1992-06-08  |  157KB  |  6,131 lines
  1. /* C Compatible Compiler Preprocessor (CCCP)
  2.    $Id: cccp.c,v 1.24 91/10/31 19:52:12 pete Exp $
  3.  
  4. Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
  5.                     Written by Paul Rubin, June 1986
  6.             Adapted to ANSI C, Richard Stallman, Jan 1987
  7.  
  8. This program is free software; you can redistribute it and/or modify it
  9. under the terms of the GNU General Public License as published by the
  10. Free Software Foundation; either version 1, or (at your option) any
  11. later version.
  12.  
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with this program; if not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22.  In other words, you are welcome to use, share and improve this program.
  23.  You are forbidden to forbid anyone else to use, share and improve
  24.  what you give them.   Help stamp out software-hoarding!  */
  25.  
  26. #if defined( _MSDOS )
  27. /* -D option doesn't work right. */
  28. #include "cccp.h"
  29. #include <stdarg.h>
  30.  
  31. int is_dsp56k_p = 0;
  32.  
  33. #if defined( _INTELC32_ )
  34. #include <errno.h>
  35. #endif
  36. #endif
  37. typedef unsigned char U_CHAR;
  38.  
  39. #ifdef EMACS
  40. #define NO_SHORTNAMES
  41. #include "../src/config.h"
  42. #ifdef open
  43. #undef open
  44. #undef read
  45. #undef write
  46. #endif /* open */
  47. #endif /* EMACS */
  48.  
  49. #ifndef EMACS
  50. #include "config.h"
  51. #endif /* not EMACS */
  52.  
  53. /* In case config.h defines these.  */
  54. #undef bcopy
  55. #undef bzero
  56. #undef bcmp
  57.  
  58. #include <sys/types.h>
  59. #include <sys/stat.h>
  60. #include <ctype.h>
  61. #include <stdio.h>
  62. #if defined( DSP56000 ) || defined( DSP96000 )
  63. #include <string.h>
  64. #endif
  65. #include <signal.h>
  66.  
  67. #if ! defined( _MSDOS )
  68. #ifndef VMS
  69. #include <sys/file.h>
  70. #ifndef USG
  71. #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  72. #include <sys/resource.h>
  73. #else
  74. #if ! defined( NeXT )
  75. /* the next string.h file already defines index and rindex */
  76. #define index strchr
  77. #define rindex strrchr
  78. #endif
  79. #include <time.h>
  80. #include <fcntl.h>
  81. #endif /* USG */
  82. #endif /* not VMS */
  83. #else
  84. #define index strchr
  85. #define rindex strrchr
  86. #include <time.h>
  87. #include <fcntl.h>
  88. #endif
  89.   
  90. /* VMS-specific definitions */
  91. #ifdef VMS
  92. #include <time.h>
  93. #include <errno.h>        /* This defines "errno" properly */
  94. #include <perror.h>        /* This defines sys_errlist/sys_nerr properly */
  95. #define O_RDONLY    0    /* Open arg for Read/Only  */
  96. #define O_WRONLY    1    /* Open arg for Write/Only */
  97. #define read(fd,buf,size)    VAX11_C_read(fd,buf,size)
  98. #define write(fd,buf,size)    VAX11_C_write(fd,buf,size)
  99. #ifdef __GNUC__
  100. #define BSTRING            /* VMS/GCC supplies the bstring routines */
  101. #endif /* __GNUC__ */
  102. #endif /* VMS */
  103.  
  104. #if ! defined( __WATCOMC__ )
  105. #define max(a,b) ((a) > (b) ? (a) : (b))
  106. #endif
  107.  
  108. /* prototype declarations.  */
  109. #if defined ( _MSDOS )
  110. int error ( char * msg, ... );
  111. int error_with_line ( int line, char * msg, ... );
  112. int warning ( char * msg, ... );
  113. void fatal ( char *str, ... );
  114. #endif
  115. /* External declarations.  */
  116.  
  117. #if ! defined( NeXT )
  118. /* NeXT string.h file defines the following */
  119. void bcopy (), bzero ();
  120. int bcmp ();
  121. #endif
  122. extern char *getenv ();
  123. extern char *version_string;
  124.  
  125. /* Forward declarations.  */
  126.  
  127. struct directive;
  128. struct file_buf;
  129. struct arglist;
  130. struct argdata;
  131.  
  132. int do_define (), do_line (), do_include (), do_undef (), do_error (),
  133.   do_pragma (), do_if (), do_xifdef (), do_else (),
  134.   do_elif (), do_endif (), do_sccs (), do_once ();
  135.  
  136. struct hashnode *install ();
  137. struct hashnode *lookup ();
  138.  
  139. #if defined( _MSDOS )
  140. void *xmalloc (), *xrealloc (), *xcalloc ();
  141. char *savestring ();
  142. #else
  143. char *xmalloc (), *xrealloc (), *xcalloc (), *savestring ();
  144. #endif
  145. #if defined( _MSDOS )
  146. void fancy_abort (), pfatal_with_name (), perror_with_name ();
  147. #else
  148. void fatal (), fancy_abort (), pfatal_with_name (), perror_with_name ();
  149. #endif
  150.  
  151. void macroexpand ();
  152. void dump_all_macros ();
  153. void conditional_skip ();
  154. void skip_if_group ();
  155. void output_line_command ();
  156. /* Last arg to output_line_command.  */
  157. enum file_change_code {same_file, enter_file, leave_file};
  158.  
  159. int grow_outbuf ();
  160. int handle_directive ();
  161. void memory_full ();
  162.  
  163. U_CHAR *macarg1 ();
  164. char *macarg ();
  165.  
  166. U_CHAR *skip_to_end_of_comment ();
  167. U_CHAR *skip_quoted_string ();
  168.  
  169. #ifndef FATAL_EXIT_CODE
  170. #define FATAL_EXIT_CODE 33    /* gnu cc command understands this */
  171. #endif
  172.  
  173. #ifndef SUCCESS_EXIT_CODE
  174. #define SUCCESS_EXIT_CODE 0    /* 0 means success on Unix.  */
  175. #endif
  176.  
  177. /* Name under which this program was invoked.  */
  178.  
  179. char *progname;
  180.  
  181. /* Nonzero means handle C++ comment syntax and use
  182.    extra default include directories for C++.  */
  183.  
  184. int cplusplus;
  185.  
  186. /* Current maximum length of directory names in the search path
  187.    for include files.  (Altered as we get more of them.)  */
  188.  
  189. int max_include_len;
  190.  
  191. /* Nonzero means copy comments into the output file.  */
  192.  
  193. int put_out_comments = 0;
  194.  
  195. /* Nonzero means don't process the ANSI trigraph sequences.  */
  196.  
  197. int no_trigraphs = 0;
  198.  
  199. /* Nonzero means print the names of included files rather than
  200.    the preprocessed output.  1 means just the #include "...",
  201.    2 means #include <...> as well.  */
  202.  
  203. int print_deps = 0;
  204.  
  205. /* Nonzero means don't output line number information.  */
  206.  
  207. int no_line_commands;
  208.  
  209. /* Nonzero means inhibit output of the preprocessed text
  210.    and instead output the definitions of all user-defined macros
  211.    in a form suitable for use as input to cccp.  */
  212.  
  213. int dump_macros;
  214.  
  215. /* Nonzero means give all the error messages the ANSI standard requires.  */
  216.  
  217. int pedantic;
  218.  
  219. /* Nonzero means warn if slash-star appears in a comment.  */
  220.  
  221. int warn_comments;
  222.  
  223. /* Nonzero means warn if there are any trigraphs.  */
  224.  
  225. int warn_trigraphs;
  226.  
  227. /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
  228.  
  229. int traditional;
  230.  
  231. /* Nonzero causes output not to be done,
  232.    but directives such as #define that have side effects
  233.    are still obeyed.  */
  234.  
  235. int no_output;
  236.  
  237. /* I/O buffer structure.
  238.    The `fname' field is nonzero for source files and #include files
  239.    and for the dummy text used for -D and -U.
  240.    It is zero for rescanning results of macro expansion
  241.    and for expanding macro arguments.  */
  242. #define INPUT_STACK_MAX 200
  243. struct file_buf {
  244.   char *fname;
  245.   int lineno;
  246.   int length;
  247.   U_CHAR *buf;
  248.   U_CHAR *bufp;
  249.   /* Macro that this level is the expansion of.
  250.      Included so that we can reenable the macro
  251.      at the end of this level.  */
  252.   struct hashnode *macro;
  253.   /* Value of if_stack at start of this file.
  254.      Used to prohibit unmatched #endif (etc) in an include file.  */
  255.   struct if_stack *if_stack;
  256.   /* Object to be freed at end of input at this level.  */
  257.   U_CHAR *free_ptr;
  258. } instack[INPUT_STACK_MAX];
  259.  
  260. /* Current nesting level of input sources.
  261.    `instack[indepth]' is the level currently being read.  */
  262. int indepth = -1;
  263. #define CHECK_DEPTH(code) \
  264.   if (indepth >= (INPUT_STACK_MAX - 1))                    \
  265.     {                                    \
  266.       error_with_line (line_for_error (instack[indepth].lineno),    \
  267.                "macro or #include recursion too deep");        \
  268.       code;                                \
  269.     }
  270.  
  271. /* Current depth in #include directives that use <...>.  */
  272. int system_include_depth = 0;
  273.  
  274. typedef struct file_buf FILE_BUF;
  275.  
  276. /* The output buffer.  Its LENGTH field is the amount of room allocated
  277.    for the buffer, not the number of chars actually present.  To get
  278.    that, subtract outbuf.buf from outbuf.bufp. */
  279.  
  280. #define OUTBUF_SIZE 10    /* initial size of output buffer */
  281. FILE_BUF outbuf;
  282.  
  283. /* Grow output buffer OBUF points at
  284.    so it can hold at least NEEDED more chars.  */
  285.  
  286. #define check_expand(OBUF, NEEDED)  \
  287.   (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED))   \
  288.    ? grow_outbuf ((OBUF), (NEEDED)) : 0)
  289.  
  290. struct file_name_list
  291.   {
  292.     struct file_name_list *next;
  293.     char *fname;
  294.   };
  295.  
  296. /* #include "file" looks in source file dir, then stack. */
  297. /* #include <file> just looks in the stack. */
  298. /* -I directories are added to the end, then the defaults are added. */
  299. struct file_name_list include_defaults[] =
  300.   {
  301. #ifndef VMS
  302. #if defined( DSP56000 ) || defined( DSP96000 )
  303.       /* we want to avoid system include dirs at all cost ! */
  304.     { 0, GCC_INCLUDE_DIR }
  305. #else
  306.     { &include_defaults[1], GCC_INCLUDE_DIR },
  307.     { &include_defaults[2], "/usr/include" },
  308.     { 0, "/usr/local/include" }
  309. #endif
  310. #else
  311.     { &include_defaults[1], "GNU_CC_INCLUDE:" },       /* GNU includes */
  312.     { &include_defaults[2], "SYS$SYSROOT:[SYSLIB.]" }, /* VAX-11 "C" includes */
  313.     { 0, "" },    /* This makes normal VMS filespecs work OK */
  314. #endif /* VMS */
  315.   };
  316.  
  317. /* These are used instead of the above, for C++.  */
  318. struct file_name_list cplusplus_include_defaults[] =
  319.   {
  320. #ifndef VMS
  321.     /* Pick up GNU C++ specific include files.  */
  322.     { &cplusplus_include_defaults[1], GPLUSPLUS_INCLUDE_DIR },
  323.     /* Use GNU CC specific header files.  */
  324.     { &cplusplus_include_defaults[2], GCC_INCLUDE_DIR },
  325.     { 0, "/usr/include" }
  326. #else
  327.     { &cplusplus_include_defaults[1], "GNU_GXX_INCLUDE:" },
  328.     { &cplusplus_include_defaults[2], "GNU_CC_INCLUDE:" },
  329.     /* VAX-11 C includes */
  330.     { &cplusplus_include_defaults[3], "SYS$SYSROOT:[SYSLIB.]" },
  331.     { 0, "" },    /* This makes normal VMS filespecs work OK */
  332. #endif /* VMS */
  333.   };
  334.  
  335. struct file_name_list *include = 0;    /* First dir to search */
  336.     /* First dir to search for <file> */
  337. struct file_name_list *first_bracket_include = 0;
  338. struct file_name_list *last_include = 0;    /* Last in chain */
  339.  
  340. /* List of included files that contained #once.  */
  341. struct file_name_list *dont_repeat_files = 0;
  342.  
  343. /* List of other included files.  */
  344. struct file_name_list *all_include_files = 0;
  345.  
  346. /* Structure allocated for every #define.  For a simple replacement
  347.    such as
  348.        #define foo bar ,
  349.    nargs = -1, the `pattern' list is null, and the expansion is just
  350.    the replacement text.  Nargs = 0 means a functionlike macro with no args,
  351.    e.g.,
  352.        #define getchar() getc (stdin) .
  353.    When there are args, the expansion is the replacement text with the
  354.    args squashed out, and the reflist is a list describing how to
  355.    build the output from the input: e.g., "3 chars, then the 1st arg,
  356.    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
  357.    The chars here come from the expansion.  Whatever is left of the
  358.    expansion after the last arg-occurrence is copied after that arg.
  359.    Note that the reflist can be arbitrarily long---
  360.    its length depends on the number of times the arguments appear in
  361.    the replacement text, not how many args there are.  Example:
  362.    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
  363.    pattern list
  364.      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
  365.    where (x, y) means (nchars, argno). */
  366.  
  367. typedef struct definition DEFINITION;
  368. struct definition {
  369.   int nargs;
  370.   int length;            /* length of expansion string */
  371.   U_CHAR *expansion;
  372.   struct reflist {
  373.     struct reflist *next;
  374.     char stringify;        /* nonzero if this arg was preceded by a
  375.                    # operator. */
  376.     char raw_before;        /* Nonzero if a ## operator before arg. */
  377.     char raw_after;        /* Nonzero if a ## operator after arg. */
  378.     int nchars;            /* Number of literal chars to copy before
  379.                    this arg occurrence.  */
  380.     int argno;            /* Number of arg to substitute (origin-0) */
  381.   } *pattern;
  382.   /* Names of macro args, concatenated in reverse order
  383.      with comma-space between them.
  384.      The only use of this is that we warn on redefinition
  385.      if this differs between the old and new definitions.  */
  386.   U_CHAR *argnames;
  387. };
  388.  
  389. /* different kinds of things that can appear in the value field
  390.    of a hash node.  Actually, this may be useless now. */
  391. union hashval {
  392.   int ival;
  393.   char *cpval;
  394.   DEFINITION *defn;
  395. };
  396.  
  397.  
  398. /* The structure of a node in the hash table.  The hash table
  399.    has entries for all tokens defined by #define commands (type T_MACRO),
  400.    plus some special tokens like __LINE__ (these each have their own
  401.    type, and the appropriate code is run when that type of node is seen.
  402.    It does not contain control words like "#define", which are recognized
  403.    by a separate piece of code. */
  404.  
  405. /* different flavors of hash nodes --- also used in keyword table */
  406. enum node_type {
  407.  T_DEFINE = 1,    /* the `#define' keyword */
  408.  T_INCLUDE,    /* the `#include' keyword */
  409.  T_IFDEF,    /* the `#ifdef' keyword */
  410.  T_IFNDEF,    /* the `#ifndef' keyword */
  411.  T_IF,        /* the `#if' keyword */
  412.  T_ELSE,    /* `#else' */
  413.  T_PRAGMA,    /* `#pragma' */
  414.  T_ELIF,    /* `#else' */
  415.  T_UNDEF,    /* `#undef' */
  416.  T_LINE,    /* `#line' */
  417.  T_ERROR,    /* `#error' */
  418.  T_ENDIF,    /* `#endif' */
  419.  T_SCCS,    /* `#sccs', used on system V.  */
  420.  T_IDENT,    /* `#ident', used on system V.  */
  421.  T_SPECLINE,    /* special symbol `__LINE__' */
  422.  T_DATE,    /* `__DATE__' */
  423.  T_FILE,    /* `__FILE__' */
  424.  T_BASE_FILE,    /* `__BASE_FILE__' */
  425.  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
  426.  T_VERSION,    /* `__VERSION__' */
  427.  T_TIME,    /* `__TIME__' */
  428.  T_CONST,    /* Constant value, used by `__STDC__' */
  429.  T_MACRO,    /* macro defined by `#define' */
  430.  T_DISABLED,    /* macro temporarily turned off for rescan */
  431.  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
  432.  T_UNUSED    /* Used for something not defined.  */
  433.  };
  434.  
  435. struct hashnode {
  436.   struct hashnode *next;    /* double links for easy deletion */
  437.   struct hashnode *prev;
  438.   struct hashnode **bucket_hdr;    /* also, a back pointer to this node's hash
  439.                    chain is kept, in case the node is the head
  440.                    of the chain and gets deleted. */
  441.   enum node_type type;        /* type of special token */
  442.   int length;            /* length of token, for quick comparison */
  443.   U_CHAR *name;            /* the actual name */
  444.   union hashval value;        /* pointer to expansion, or whatever */
  445. };
  446.  
  447. typedef struct hashnode HASHNODE;
  448.  
  449. /* Some definitions for the hash table.  The hash function MUST be
  450.    computed as shown in hashf () below.  That is because the rescan
  451.    loop computes the hash value `on the fly' for most tokens,
  452.    in order to avoid the overhead of a lot of procedure calls to
  453.    the hashf () function.  Hashf () only exists for the sake of
  454.    politeness, for use when speed isn't so important. */
  455.  
  456. #define HASHSIZE 1403
  457. HASHNODE *hashtab[HASHSIZE];
  458. #define HASHSTEP(old, c) ((old << 2) + c)
  459. #define MAKE_POS(v) (v & ~0x80000000) /* make number positive */
  460.  
  461. /* Symbols to predefine.  */
  462.  
  463. #ifdef CPP_PREDEFINES
  464. char *predefs = CPP_PREDEFINES;
  465. #else
  466. char *predefs = "";
  467. #endif
  468.  
  469. /* `struct directive' defines one #-directive, including how to handle it.  */
  470.  
  471. struct directive {
  472.   int length;            /* Length of name */
  473.   int (*func)();        /* Function to handle directive */
  474.   char *name;            /* Name of directive */
  475.   enum node_type type;        /* Code which describes which directive. */
  476.   char angle_brackets;        /* Nonzero => <...> is special.  */
  477.   char traditional_comments;    /* Nonzero: keep comments if -traditional.  */
  478.   char pass_thru;        /* Copy preprocessed directive to output file.  */
  479. };
  480.  
  481. /* Here is the actual list of #-directives, most-often-used first.  */
  482.  
  483. struct directive directive_table[] = {
  484.   {  6, do_define, "define", T_DEFINE, 0, 1},
  485.   {  2, do_if, "if", T_IF},
  486.   {  5, do_xifdef, "ifdef", T_IFDEF},
  487.   {  6, do_xifdef, "ifndef", T_IFNDEF},
  488.   {  5, do_endif, "endif", T_ENDIF},
  489.   {  4, do_else, "else", T_ELSE},
  490.   {  4, do_elif, "elif", T_ELIF},
  491.   {  4, do_line, "line", T_LINE},
  492.   {  7, do_include, "include", T_INCLUDE, 1},
  493.   {  5, do_undef, "undef", T_UNDEF},
  494.   {  5, do_error, "error", T_ERROR},
  495. #ifdef SCCS_DIRECTIVE
  496.   {  4, do_sccs, "sccs", T_SCCS},
  497. #endif
  498.   {  6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
  499.   {  -1, 0, "", T_UNUSED},
  500. };
  501.  
  502. /* table to tell if char can be part of a C identifier. */
  503. U_CHAR is_idchar[256];
  504. /* table to tell if char can be first char of a c identifier. */
  505. U_CHAR is_idstart[256];
  506. /* table to tell if c is horizontal space.  */
  507. U_CHAR is_hor_space[256];
  508. /* table to tell if c is horizontal or vertical space.  */
  509. U_CHAR is_space[256];
  510.  
  511. #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
  512. #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
  513.   
  514. int errors = 0;            /* Error counter for exit code */
  515.  
  516. /* Zero means dollar signs are punctuation.
  517.    -$ stores 0; -traditional, stores 1.  Default is 1 for VMS, 0 otherwise.
  518.    This must be 0 for correct processing of this ANSI C program:
  519.     #define foo(a) #a
  520.     #define lose(b) foo(b)
  521.     #define test$
  522.     lose(test)    */
  523. #ifndef DOLLARS_IN_IDENTIFIERS
  524. #define DOLLARS_IN_IDENTIFIERS 0
  525. #endif
  526. int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
  527.  
  528. FILE_BUF expand_to_temp_buffer ();
  529.  
  530. DEFINITION *collect_expansion ();
  531.  
  532. /* Stack of conditionals currently in progress
  533.    (including both successful and failing conditionals).  */
  534.  
  535. struct if_stack {
  536.   struct if_stack *next;    /* for chaining to the next stack frame */
  537.   char *fname;        /* copied from input when frame is made */
  538.   int lineno;            /* similarly */
  539.   int if_succeeded;        /* true if a leg of this if-group
  540.                     has been passed through rescan */
  541.   enum node_type type;        /* type of last directive seen in this group */
  542. };
  543. typedef struct if_stack IF_STACK_FRAME;
  544. IF_STACK_FRAME *if_stack = NULL;
  545.  
  546. /* Buffer of -M output.  */
  547.  
  548. char *deps_buffer;
  549.  
  550. /* Number of bytes allocated in above.  */
  551. int deps_allocated_size;
  552.  
  553. /* Number of bytes used.  */
  554. int deps_size;
  555.  
  556. /* Number of bytes since the last newline.  */
  557. int deps_column;
  558.  
  559. /* Nonzero means -I- has been seen,
  560.    so don't look for #include "foo" the source-file directory.  */
  561. int ignore_srcdir;
  562.  
  563. /* Handler for SIGPIPE.  */
  564.  
  565. static void
  566. pipe_closed ()
  567. {
  568.   fatal ("output pipe has been closed");
  569. }
  570.  
  571.  
  572. #if defined ( _MSDOS )
  573. /* the fabulous MSDOS forces use to allocate a fake argv incase we must
  574.    reallocate argv later. */
  575. int
  576. main (argc, argv)
  577.      int argc;
  578.      char **argv;
  579. {
  580.     int i = 0;
  581.     char **fake_argv;
  582.     
  583.     fake_argv = (char **) xmalloc( sizeof( char* ) * ( argc + 1 ) );
  584.     while ( argv[ i ] != NULL )
  585.     {
  586.     fake_argv[ i ] = (char*) xmalloc ( sizeof( char ) * ( strlen( argv[ i ] ) + 1 ) );
  587.     strcpy( fake_argv[ i ], argv[ i ] );
  588.     i ++ ;
  589.     }
  590.     
  591.     fake_main( argc, fake_argv );
  592. }
  593.  
  594. fake_main( argc, argv )
  595.     int argc;
  596.     char **argv;
  597. {
  598. #else
  599. int
  600. main (argc, argv)
  601.      int argc;
  602.      char **argv;
  603. {
  604. #endif
  605.   int st_mode;
  606.   long st_size;
  607.   char *in_fname, *out_fname;
  608.   int f, i;
  609.   FILE_BUF *fp;
  610. #if defined( DSP56000 ) || defined( DSP96000 )
  611.   char **pend_files;
  612.   char **pend_defs;
  613.   char **pend_undefs;
  614. #else
  615.   char **pend_files = (char **) xmalloc (argc * sizeof (char *));
  616.   char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
  617.   char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
  618. #endif
  619.   int inhibit_predefs = 0;
  620.   int no_standard_includes = 0;
  621.  
  622.   /* Non-0 means don't output the preprocessed program.  */
  623.   int inhibit_output = 0;
  624.  
  625.   /* Stream on which to print the dependency information.  */
  626.   FILE *deps_stream = 0;
  627.   /* Target-name to write with the dependency information.  */
  628.   char *deps_target = 0;
  629.  
  630. #if defined( DSP56000 ) || defined( DSP96000 )
  631.   extend_argv( &argc, &argv );
  632.   pend_files = (char **) xmalloc (argc * sizeof (char *));
  633.   pend_defs = (char **) xmalloc (argc * sizeof (char *));
  634.   pend_undefs = (char **) xmalloc (argc * sizeof (char *));
  635. #endif
  636.  
  637. #if defined( DSP56000 ) || defined( DSP96000 )
  638.   {
  639.       extern char *getenv ( );
  640.       char *dsploc = getenv ( "DSPLOC" );
  641.  
  642.       if ( NULL != dsploc )
  643.       {
  644.       char *manip = dsploc;
  645.       int dsploclen;
  646.  
  647. #if defined( _MSDOS )
  648.       char *dirstr = "\\";
  649. #else
  650.       char *dirstr = "/";
  651. #endif
  652.       
  653.       /* allow for growth. */
  654.       dsploc = strcpy ( (char*) xmalloc ( strlen ( dsploc ) +
  655.                      sizeof ( "$dsp$" )), dsploc );
  656.       
  657.       /* root the dsp dir at dsploc: usually /usr/local */
  658.       while ( '\0' != ( * manip ))
  659.       {
  660.           ++ manip;
  661.       }
  662.  
  663.       if ( dirstr[0] != ( * ( -- manip )))
  664.       {
  665.           strcat ( dsploc, dirstr );
  666.       }
  667.       strcat ( dsploc, "dsp" );
  668.       strcat ( dsploc, dirstr );
  669.       
  670.       dsploclen = strlen ( dsploc );
  671.  
  672.       /* jam dsploc into everything that needs it */
  673.       
  674.       include_defaults[0].fname = 
  675.           xmalloc ( dsploclen + sizeof ( "include" ));
  676.       strcpy ( include_defaults[0].fname, dsploc );
  677.       strcat ( include_defaults[0].fname, "include" );
  678.       }
  679.   }
  680. #endif 
  681. #ifdef RLIMIT_STACK
  682.   /* Get rid of any avoidable limit on stack size.  */
  683.   {
  684.     struct rlimit rlim;
  685.  
  686.     /* Set the stack limit huge so that alloca (particularly stringtab
  687.      * in dbxread.c) does not fail. */
  688.     getrlimit (RLIMIT_STACK, &rlim);
  689.     rlim.rlim_cur = rlim.rlim_max;
  690.     setrlimit (RLIMIT_STACK, &rlim);
  691.   }
  692. #endif /* RLIMIT_STACK defined */
  693.  
  694.   progname = argv[0];
  695. #ifdef VMS
  696.   {
  697.     /* Remove directories from PROGNAME.  */
  698.     char *s;
  699. #if ! defined( NeXT )
  700.     /* the next string.h file already defines rindex */
  701.     extern char *rindex ();
  702. #endif
  703.  
  704.     progname = savestring (argv[0]);
  705.  
  706.     if (!(s = rindex (progname, ']')))
  707.       s = rindex (progname, ':');
  708.     if (s)
  709.       strcpy (progname, s+1);
  710.     if (s = rindex (progname, '.'))
  711.       *s = '\0';
  712.   }
  713. #endif
  714.  
  715.   in_fname = NULL;
  716.   out_fname = NULL;
  717.  
  718.   /* Initialize is_idchar to allow $.  */
  719.   dollars_in_ident = 1;
  720.   initialize_char_syntax ();
  721.   dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
  722.  
  723.   no_line_commands = 0;
  724.   no_trigraphs = 1;
  725.   dump_macros = 0;
  726.   no_output = 0;
  727.   cplusplus = 0;
  728. #ifdef CPLUSPLUS
  729.   cplusplus = 1;
  730. #endif
  731.  
  732. #if ! defined( _MSDOS )
  733.   signal (SIGPIPE, pipe_closed);
  734. #endif
  735.  
  736. #if defined( DSP56000 ) || defined( DSP96000 )
  737. /* jam this wide open, 'cause it is dynamic off of DSPLOC in this version. */
  738.   max_include_len = 1024;
  739. #else
  740. #ifndef VMS
  741.   max_include_len
  742.     = max (max (sizeof (GCC_INCLUDE_DIR),
  743.         sizeof (GPLUSPLUS_INCLUDE_DIR)),
  744.        sizeof ("/usr/include/CC"));
  745. #else /* VMS */
  746.   max_include_len
  747.     = sizeof("SYS$SYSROOT:[SYSLIB.]");
  748. #endif /* VMS */
  749. #endif
  750.  
  751.   bzero (pend_files, argc * sizeof (char *));
  752.   bzero (pend_defs, argc * sizeof (char *));
  753.   bzero (pend_undefs, argc * sizeof (char *));
  754.  
  755.   /* Process switches and find input file name.  */
  756.  
  757.   for (i = 1; i < argc; i++) {
  758.     if (argv[i][0] != '-') {
  759.       if (out_fname != NULL)
  760.     fatal ("Usage: %s [switches] input output", argv[0]);
  761.       else if (in_fname != NULL)
  762.     out_fname = argv[i];
  763.       else
  764.     in_fname = argv[i];
  765.     } else {
  766.       switch (argv[i][1]) {
  767.  
  768.       case 'i':
  769.     if (argv[i][2] != 0)
  770.       pend_files[i] = argv[i] + 2;
  771.     else if (i + 1 == argc)
  772.       fatal ("Filename missing after -i option");
  773.     else
  774.       pend_files[i] = argv[i+1], i++;
  775.     break;
  776.  
  777.       case 'o':
  778.     if (out_fname != NULL)
  779.       fatal ("Output filename specified twice");
  780.     if (i + 1 == argc)
  781.       fatal ("Filename missing after -o option");
  782.     out_fname = argv[++i];
  783.     if (!strcmp (out_fname, "-"))
  784.       out_fname = "";
  785.     break;
  786.  
  787.       case 'p':
  788.     pedantic = 1;
  789.     break;
  790.  
  791.       case 't':
  792.     if (!strcmp (argv[i], "-traditional")) {
  793. #if defined( DSP56000 ) || defined( DSP96000 )
  794.       fatal ("-traditional option NOT supported");
  795. #else
  796.       traditional = 1;
  797.       dollars_in_ident = 1;
  798. #endif
  799.     } else if (!strcmp (argv[i], "-trigraphs")) {
  800.       no_trigraphs = 0;
  801.     }
  802.     break;
  803.  
  804.       case '+':
  805.     cplusplus = 1;
  806.     break;
  807.  
  808.       case 'W':
  809.     if (!strcmp (argv[i], "-Wtrigraphs")) {
  810.       warn_trigraphs = 1;
  811.     }
  812.     if (!strcmp (argv[i], "-Wcomments"))
  813.       warn_comments = 1;
  814.     if (!strcmp (argv[i], "-Wcomment"))
  815.       warn_comments = 1;
  816.     if (!strcmp (argv[i], "-Wall")) {
  817.       warn_trigraphs = 1;
  818.       warn_comments = 1;
  819.     }
  820.     break;
  821.  
  822.       case 'M':
  823.     if (!strcmp (argv[i], "-M"))
  824.       print_deps = 2;
  825.     else if (!strcmp (argv[i], "-MM"))
  826.       print_deps = 1;
  827.     inhibit_output = 1;
  828.     break;
  829.  
  830.       case 'd':
  831.     dump_macros = 1;
  832.     no_output = 1;
  833.     break;
  834.  
  835.       case 'v':
  836.     fprintf (stderr, "GNU CPP version %s\n", version_string);
  837.     break;
  838.  
  839.       case 'D':
  840.     {
  841.       char *p, *p1;
  842.  
  843.       if (argv[i][2] != 0)
  844.         p = argv[i] + 2;
  845.       else if (i + 1 == argc)
  846.         fatal ("Macro name missing after -D option");
  847.       else
  848.         p = argv[++i];
  849.  
  850.       if ((p1 = (char *) index (p, '=')) != NULL)
  851.         *p1 = ' ';
  852.       pend_defs[i] = p;
  853.     }
  854.     break;
  855.  
  856.       case 'U':        /* JF #undef something */
  857.     if (argv[i][2] != 0)
  858.       pend_undefs[i] = argv[i] + 2;
  859.     else if (i + 1 == argc)
  860.       fatal ("Macro name missing after -U option");
  861.     else
  862.       pend_undefs[i] = argv[i+1], i++;
  863.     break;
  864.  
  865.       case 'C':
  866.     put_out_comments = 1;
  867.     break;
  868.  
  869.       case 'E':            /* -E comes from cc -E; ignore it.  */
  870.     break;
  871.  
  872.       case 'P':
  873.     no_line_commands = 1;
  874.     break;
  875.  
  876.       case '$':            /* Don't include $ in identifiers.  */
  877.     dollars_in_ident = 0;
  878.     break;
  879.  
  880.       case 'I':            /* Add directory to path for includes.  */
  881.     {
  882.       struct file_name_list *dirtmp;
  883.  
  884.       if (! ignore_srcdir && !strcmp (argv[i] + 2, "-"))
  885.         ignore_srcdir = 1;
  886.       else {
  887.         dirtmp = (struct file_name_list *)
  888.           xmalloc (sizeof (struct file_name_list));
  889.         dirtmp->next = 0;        /* New one goes on the end */
  890.         if (include == 0)
  891.           include = dirtmp;
  892.         else
  893.           last_include->next = dirtmp;
  894.         last_include = dirtmp;    /* Tail follows the last one */
  895.         if (argv[i][2] != 0)
  896.           dirtmp->fname = argv[i] + 2;
  897.         else if (i + 1 == argc)
  898.           fatal ("Directory name missing after -I option");
  899.         else
  900.           dirtmp->fname = argv[++i];
  901.         if (strlen (dirtmp->fname) > max_include_len)
  902.           max_include_len = strlen (dirtmp->fname);
  903.         if (ignore_srcdir && first_bracket_include == 0)
  904.           first_bracket_include = dirtmp;
  905.         }
  906.     }
  907.     break;
  908.  
  909.       case 'n':
  910.     /* -nostdinc causes no default include directories.
  911.        You must specify all include-file directories with -I.  */
  912.     no_standard_includes = 1;
  913.     break;
  914.  
  915.       case 'u':
  916.     /* Sun compiler passes undocumented switch "-undef".
  917.        Let's assume it means to inhibit the predefined symbols.  */
  918.     inhibit_predefs = 1;
  919.     break;
  920.  
  921.       case '\0': /* JF handle '-' as file name meaning stdin or stdout */
  922.     if (in_fname == NULL) {
  923.       in_fname = "";
  924.       break;
  925.     } else if (out_fname == NULL) {
  926.       out_fname = "";
  927.       break;
  928.     }    /* else fall through into error */
  929.  
  930.       default:
  931.     fatal ("Invalid option `%s'", argv[i]);
  932.       }
  933.     }
  934.   }
  935.  
  936.   /* Now that dollars_in_ident is known, initialize is_idchar.  */
  937.   initialize_char_syntax ();
  938.  
  939.   /* Install __LINE__, etc.  Must follow initialize_char_syntax
  940.      and option processing.  */
  941.   initialize_builtins ();
  942.  
  943.   /* Do standard #defines that identify processor type.  */
  944.  
  945.   if (!inhibit_predefs) {
  946.     char *p = (char *) alloca (strlen (predefs) + 1);
  947.     strcpy (p, predefs);
  948.     while (*p) {
  949.       char *q;
  950.       if (p[0] != '-' || p[1] != 'D')
  951.     abort ();
  952.       q = &p[2];
  953.       while (*p && *p != ' ') p++;
  954.       if (*p != 0)
  955.     *p++= 0;
  956.       make_definition (q);
  957.     }
  958.   }
  959.  
  960.   /* Do defines specified with -D.  */
  961.   for (i = 1; i < argc; i++)
  962.     if (pend_defs[i])
  963. #if defined( _MSDOS )
  964.     {
  965.     /* we need to know whether we're a g56k or a g96k */
  966.     if ( 0 == strncmp ( "__DSP56K__", pend_defs[i],
  967.                sizeof ( "__DSP56K__" ) - 1 ))
  968.     {
  969.         is_dsp56k_p = 1;
  970.     }
  971.     make_definition (pend_defs[i]);
  972.     }    
  973. #else
  974.       make_definition (pend_defs[i]);
  975. #endif
  976.  
  977.   /* Do undefines specified with -U.  */
  978.   for (i = 1; i < argc; i++)
  979.     if (pend_undefs[i])
  980.       make_undef (pend_undefs[i]);
  981.  
  982.   /* Unless -fnostdinc,
  983.      tack on the standard include file dirs to the specified list */
  984.   if (!no_standard_includes) {
  985.     if (include == 0)
  986.       include = (cplusplus ? cplusplus_include_defaults : include_defaults);
  987.     else
  988.       last_include->next
  989.     = (cplusplus ? cplusplus_include_defaults : include_defaults);
  990.     /* Make sure the list for #include <...> also has the standard dirs.  */
  991.     if (ignore_srcdir && first_bracket_include == 0)
  992.       first_bracket_include
  993.     = (cplusplus ? cplusplus_include_defaults : include_defaults);
  994.   }
  995.  
  996.   /* Initialize output buffer */
  997.  
  998.   outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
  999.   outbuf.bufp = outbuf.buf;
  1000.   outbuf.length = OUTBUF_SIZE;
  1001.  
  1002.   /* Scan the -i files before the main input.
  1003.      Much like #including them, but with no_output set
  1004.      so that only their macro definitions matter.  */
  1005.  
  1006.   no_output++;
  1007.   for (i = 1; i < argc; i++)
  1008.     if (pend_files[i]) {
  1009. #if defined ( _MSDOS )
  1010.         /* we need to specify the input files as text, so that DOS
  1011.            Ctrl-Ms are weeded out by the system calls. */
  1012.  
  1013.         int fd = open (pend_files[i], O_RDONLY | O_TEXT, 0666);
  1014. #else
  1015.         int fd = open (pend_files[i], O_RDONLY, 0666);
  1016. #endif
  1017.       if (fd < 0) {
  1018.     perror_with_name (pend_files[i]);
  1019.     return FATAL_EXIT_CODE;
  1020.       }
  1021.       finclude (fd, pend_files[i], &outbuf);
  1022.     }
  1023.   no_output--;
  1024.  
  1025.   /* Create an input stack level for the main input file
  1026.      and copy the entire contents of the file into it.  */
  1027.  
  1028.   fp = &instack[++indepth];
  1029.  
  1030.   /* JF check for stdin */
  1031.   if (in_fname == NULL || *in_fname == 0) {
  1032.     in_fname = "";
  1033.     f = 0;
  1034. #if defined( _MSDOS )
  1035.     /* we need to specify the input files as text, so that DOS
  1036.        Ctrl-Ms are weeded out by the system calls. */
  1037.  
  1038.   } else if ((f = open (in_fname, O_RDONLY | O_TEXT, 0666)) < 0)
  1039. #else
  1040.   } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
  1041. #endif
  1042.     goto perror;
  1043.  
  1044.   /* Either of two environment variables can specify output of deps.
  1045.      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
  1046.      where OUTPUT_FILE is the file to write deps info to
  1047.      and DEPS_TARGET is the target to mention in the deps.  */
  1048.  
  1049.   if (print_deps == 0
  1050.       && (getenv ("SUNPRO_DEPENDENCIES") != 0
  1051.       || getenv ("DEPENDENCIES_OUTPUT") != 0))
  1052.     {
  1053.       char *spec = getenv ("DEPENDENCIES_OUTPUT");
  1054.       char *s;
  1055.       char *output_file;
  1056.  
  1057.       if (spec == 0)
  1058.     {
  1059.       spec = getenv ("SUNPRO_DEPENDENCIES");
  1060.       print_deps = 2;
  1061.     }
  1062.       else
  1063.     print_deps = 1;
  1064.  
  1065.       s = spec;
  1066.       /* Find the space before the DEPS_TARGET, if there is one.  */
  1067.       /* Don't use `index'; that causes trouble on USG.  */
  1068.       while (*s != 0 && *s != ' ') s++;
  1069.       if (*s != 0)
  1070.     {
  1071.       deps_target = s + 1;
  1072.       output_file = (char *) xmalloc (s - spec + 1);
  1073.       bcopy (spec, output_file, s - spec);
  1074.       output_file[s - spec] = 0;
  1075.     }
  1076.       else
  1077.     {
  1078.       deps_target = 0;
  1079.       output_file = spec;
  1080.     }
  1081.       
  1082. #if defined( _MSDOS )
  1083.       /* output in "binary" mode so that DOS Ctrl-Ms aren't inserted into 
  1084.      the output. */
  1085.       deps_stream = fopen (output_file, "ab");
  1086. #else
  1087.       deps_stream = fopen (output_file, "a");
  1088. #endif
  1089.       if (deps_stream == 0)
  1090.     pfatal_with_name (output_file);
  1091.     }
  1092.   /* If the -M option was used, output the deps to standard output.  */
  1093.   else if (print_deps)
  1094.     deps_stream = stdout;
  1095.  
  1096.   /* For -M, print the expected object file name
  1097.      as the target of this Make-rule.  */
  1098.   if (print_deps) {
  1099.     deps_allocated_size = 200;
  1100.     deps_buffer = (char *) xmalloc (deps_allocated_size);
  1101.     deps_buffer[0] = 0;
  1102.     deps_size = 0;
  1103.     deps_column = 0;
  1104.  
  1105.     if (deps_target) {
  1106.       deps_output (deps_target, 0);
  1107.       deps_output (":", 0);
  1108.     } else if (*in_fname == 0)
  1109.       deps_output ("-: ", 0);
  1110.     else {
  1111.       int len;
  1112.       char *p = in_fname;
  1113.       char *p1 = p;
  1114.       /* Discard all directory prefixes from P.  */
  1115.       while (*p1) {
  1116.     if (*p1 == '/')
  1117.       p = p1 + 1;
  1118.     p1++;
  1119.       }
  1120.       /* Output P, but remove known suffixes.  */
  1121.       len = strlen (p);
  1122.       if (p[len - 2] == '.' && (p[len - 1] == 'c' || p[len - 1] == 'C'))
  1123.     deps_output (p, len - 2);
  1124.       else if (p[len - 3] == '.'
  1125.            && p[len - 2] == 'c'
  1126.            && p[len - 1] == 'c')
  1127.     deps_output (p, len - 3);
  1128.       else
  1129.     deps_output (p, 0);
  1130.       /* Supply our own suffix.  */
  1131.       deps_output (".o : ", 0);
  1132.       deps_output (in_fname, 0);
  1133.       deps_output (" ", 0);
  1134.     }
  1135.   }
  1136.  
  1137. #if defined( _MSDOS )
  1138.   file_size_and_mode (in_fname, &st_mode, &st_size);
  1139. #else
  1140.   file_size_and_mode (f, &st_mode, &st_size);
  1141. #endif
  1142.   fp->fname = in_fname;
  1143.   fp->lineno = 1;
  1144.   /* JF all this is mine about reading pipes and ttys */
  1145.   if ((st_mode & S_IFMT) != S_IFREG) {
  1146.     /* Read input from a file that is not a normal disk file.
  1147.        We cannot preallocate a buffer with the correct size,
  1148.        so we must read in the file a piece at the time and make it bigger.  */
  1149.     int size;
  1150.     int bsize;
  1151.     int cnt;
  1152.     U_CHAR *bufp;
  1153.  
  1154.     bsize = 2000;
  1155.     size = 0;
  1156.     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
  1157.     bufp = fp->buf;
  1158.     for (;;) {
  1159.       cnt = read (f, bufp, bsize - size);
  1160.       if (cnt < 0) goto perror;    /* error! */
  1161.       if (cnt == 0) break;    /* End of file */
  1162.       size += cnt;
  1163.       bufp += cnt;
  1164.       if (bsize == size) {    /* Buffer is full! */
  1165.         bsize *= 2;
  1166.         fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
  1167.     bufp = fp->buf + size;    /* May have moved */
  1168.       }
  1169.     }
  1170.     fp->length = size;
  1171.   } else {
  1172.     /* Read a file whose size we can determine in advance.
  1173.        For the sake of VMS, st_size is just an upper bound.  */
  1174.     long i;
  1175.     fp->length = 0;
  1176. #if ! defined( _MSDOS )
  1177.     fp->buf = (U_CHAR *) xmalloc (st_size + 2);
  1178. #else
  1179.     fp->buf = (U_CHAR *) xmalloc ( (int) (st_size + 2) );
  1180. #endif
  1181.  
  1182.     while (st_size > 0) {
  1183.       i = read (f, fp->buf + fp->length, st_size);
  1184.       if (i <= 0) {
  1185.         if (i == 0) break;
  1186.     goto perror;
  1187.       }
  1188.       fp->length += i;
  1189.       st_size -= i;
  1190.     }
  1191.   }
  1192.   fp->bufp = fp->buf;
  1193.   fp->if_stack = if_stack;
  1194.   
  1195.   /* Unless inhibited, convert trigraphs in the input.  */
  1196.  
  1197.   if (!no_trigraphs)
  1198.     trigraph_pcp (fp);
  1199.  
  1200.   /* Make sure data ends with a newline.  And put a null after it.  */
  1201.  
  1202.   if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
  1203.     fp->buf[fp->length++] = '\n';
  1204.   fp->buf[fp->length] = '\0';
  1205.  
  1206.   /* Now that we know the input file is valid, open the output.  */
  1207.  
  1208.   if (!out_fname || !strcmp (out_fname, ""))
  1209.     out_fname = "stdout";
  1210. #if defined( _MSDOS )
  1211.   /* output in "binary" mode so that DOS Ctrl-Ms aren't inserted into 
  1212.      the output. */
  1213.  
  1214.   else if (! freopen (out_fname, "wb", stdout))
  1215. #else
  1216.   else if (! freopen (out_fname, "w", stdout))
  1217. #endif
  1218.     pfatal_with_name (out_fname);
  1219.  
  1220.   output_line_command (fp, &outbuf, 0, same_file);
  1221.  
  1222.   /* Scan the input, processing macros and directives.  */
  1223.  
  1224.   rescan (&outbuf, 0);
  1225.  
  1226.   /* Now we have processed the entire input
  1227.      Write whichever kind of output has been requested.  */
  1228.  
  1229.  
  1230.   if (dump_macros)
  1231.     dump_all_macros ();
  1232.   else if (! inhibit_output && deps_stream != stdout) {
  1233.     if (write (fileno (stdout), outbuf.buf, outbuf.bufp - outbuf.buf) < 0)
  1234.       fatal ("I/O error on output");
  1235.   }
  1236.  
  1237.   if (print_deps) {
  1238.     fputs (deps_buffer, deps_stream);
  1239.     putc ('\n', deps_stream);
  1240.     if (deps_stream != stdout) {
  1241.       fclose (deps_stream);
  1242.       if (ferror (deps_stream))
  1243.     fatal ("I/O error on output");
  1244.     }
  1245.   }
  1246.  
  1247.   if (ferror (stdout))
  1248.     fatal ("I/O error on output");
  1249.  
  1250.   if (errors)
  1251.     exit (FATAL_EXIT_CODE);
  1252.   exit (SUCCESS_EXIT_CODE);
  1253.  
  1254.  perror:
  1255.   pfatal_with_name (in_fname);
  1256. }
  1257.  
  1258. /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
  1259.    before main CCCP processing.  Name `pcp' is also in honor of the
  1260.    drugs the trigraph designers must have been on.
  1261.  
  1262.    Using an extra pass through the buffer takes a little extra time,
  1263.    but is infinitely less hairy than trying to handle ??/" inside
  1264.    strings, etc. everywhere, and also makes sure that trigraphs are
  1265.    only translated in the top level of processing. */
  1266.  
  1267. trigraph_pcp (buf)
  1268.      FILE_BUF *buf;
  1269. {
  1270.   register U_CHAR c, *fptr, *bptr, *sptr;
  1271.   int len;
  1272.  
  1273.   fptr = bptr = sptr = buf->buf;
  1274. #if defined( NeXT )
  1275.   while ((sptr = (U_CHAR *) index ( (char *) sptr, '?')) != NULL) {
  1276. #else
  1277.   while ((sptr = (U_CHAR *) index (sptr, '?')) != NULL) {
  1278. #endif
  1279.     if (*++sptr != '?')
  1280.       continue;
  1281.     switch (*++sptr) {
  1282.       case '=':
  1283.       c = '#';
  1284.       break;
  1285.     case '(':
  1286.       c = '[';
  1287.       break;
  1288.     case '/':
  1289.       c = '\\';
  1290.       break;
  1291.     case ')':
  1292.       c = ']';
  1293.       break;
  1294.     case '\'':
  1295.       c = '^';
  1296.       break;
  1297.     case '<':
  1298.       c = '{';
  1299.       break;
  1300.     case '!':
  1301.       c = '|';
  1302.       break;
  1303.     case '>':
  1304.       c = '}';
  1305.       break;
  1306.     case '-':
  1307.       c  = '~';
  1308.       break;
  1309.     case '?':
  1310.       sptr--;
  1311.       continue;
  1312.     default:
  1313.       continue;
  1314.     }
  1315.     len = sptr - fptr - 2;
  1316.     if (bptr != fptr && len > 0)
  1317.       bcopy (fptr, bptr, len);    /* BSD doc says bcopy () works right
  1318.                    for overlapping strings.  In ANSI
  1319.                    C, this will be memmove (). */
  1320.     bptr += len;
  1321.     *bptr++ = c;
  1322.     fptr = ++sptr;
  1323.   }
  1324.   len = buf->length - (fptr - buf->buf);
  1325.   if (bptr != fptr && len > 0)
  1326.     bcopy (fptr, bptr, len);
  1327.   buf->length -= fptr - bptr;
  1328.   buf->buf[buf->length] = '\0';
  1329.   if (warn_trigraphs && fptr != bptr)
  1330.     warning ("%d trigraph(s) encountered", (fptr - bptr) / 2);
  1331. }
  1332.  
  1333. /* Move all backslash-newline pairs out of embarrassing places.
  1334.    Exchange all such pairs following BP
  1335.    with any potentially-embarrasing characters that follow them.
  1336.    Potentially-embarrassing characters are / and *
  1337.    (because a backslash-newline inside a comment delimiter
  1338.    would cause it not to be recognized).  */
  1339.  
  1340. newline_fix (bp)
  1341.      U_CHAR *bp;
  1342. {
  1343.   register U_CHAR *p = bp;
  1344.   register int count = 0;
  1345.  
  1346.   /* First count the backslash-newline pairs here.  */
  1347.  
  1348.   while (*p++ == '\\' && *p++ == '\n')
  1349.     count++;
  1350.  
  1351.   p = bp + count * 2;
  1352.  
  1353.   /* What follows the backslash-newlines is not embarrassing.  */
  1354.  
  1355.   if (count == 0 || (*p != '/' && *p != '*'))
  1356.     return;
  1357.  
  1358.   /* Copy all potentially embarrassing characters
  1359.      that follow the backslash-newline pairs
  1360.      down to where the pairs originally started.  */
  1361.  
  1362.   while (*p == '*' || *p == '/')
  1363.     *bp++ = *p++;
  1364.  
  1365.   /* Now write the same number of pairs after the embarrassing chars.  */
  1366.   while (count-- > 0) {
  1367.     *bp++ = '\\';
  1368.     *bp++ = '\n';
  1369.   }
  1370. }
  1371.  
  1372. /* Like newline_fix but for use within a directive-name.
  1373.    Move any backslash-newlines up past any following symbol constituents.  */
  1374.  
  1375. name_newline_fix (bp)
  1376.      U_CHAR *bp;
  1377. {
  1378.   register U_CHAR *p = bp;
  1379.   register int count = 0;
  1380.  
  1381.   /* First count the backslash-newline pairs here.  */
  1382.  
  1383.   while (*p++ == '\\' && *p++ == '\n')
  1384.     count++;
  1385.  
  1386.   p = bp + count * 2;
  1387.  
  1388.   /* What follows the backslash-newlines is not embarrassing.  */
  1389.  
  1390.   if (count == 0 || !is_idchar[*p])
  1391.     return;
  1392.  
  1393.   /* Copy all potentially embarrassing characters
  1394.      that follow the backslash-newline pairs
  1395.      down to where the pairs originally started.  */
  1396.  
  1397.   while (is_idchar[*p])
  1398.     *bp++ = *p++;
  1399.  
  1400.   /* Now write the same number of pairs after the embarrassing chars.  */
  1401.   while (count-- > 0) {
  1402.     *bp++ = '\\';
  1403.     *bp++ = '\n';
  1404.   }
  1405. }
  1406.  
  1407. /*
  1408.  * The main loop of the program.
  1409.  *
  1410.  * Read characters from the input stack, transferring them to the
  1411.  * output buffer OP.
  1412.  *
  1413.  * Macros are expanded and push levels on the input stack.
  1414.  * At the end of such a level it is popped off and we keep reading.
  1415.  * At the end of any other kind of level, we return.
  1416.  * #-directives are handled, except within macros.
  1417.  *
  1418.  * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
  1419.  * and insert them when appropriate.  This is set while scanning macro
  1420.  * arguments before substitution.  It is zero when scanning for final output.
  1421.  *   There are three types of Newline markers:
  1422.  *   * Newline -  follows a macro name that was not expanded
  1423.  *     because it appeared inside an expansion of the same macro.
  1424.  *     This marker prevents future expansion of that identifier.
  1425.  *     When the input is rescanned into the final output, these are deleted.
  1426.  *     These are also deleted by ## concatenation.
  1427.  *   * Newline Space (or Newline and any other whitespace character)
  1428.  *     stands for a place that tokens must be separated or whitespace
  1429.  *     is otherwise desirable, but where the ANSI standard specifies there
  1430.  *     is no whitespace.  This marker turns into a Space (or whichever other
  1431.  *     whitespace char appears in the marker) in the final output,
  1432.  *     but it turns into nothing in an argument that is stringified with #.
  1433.  *     Such stringified arguments are the only place where the ANSI standard
  1434.  *     specifies with precision that whitespace may not appear.
  1435.  *
  1436.  * During this function, IP->bufp is kept cached in IBP for speed of access.
  1437.  * Likewise, OP->bufp is kept in OBP.  Before calling a subroutine
  1438.  * IBP, IP and OBP must be copied back to memory.  IP and IBP are
  1439.  * copied back with the RECACHE macro.  OBP must be copied back from OP->bufp
  1440.  * explicitly, and before RECACHE, since RECACHE uses OBP.
  1441.  */
  1442.  
  1443. rescan (op, output_marks)
  1444.      FILE_BUF *op;
  1445.      int output_marks;
  1446. {
  1447.   /* Character being scanned in main loop.  */
  1448.   register U_CHAR c;
  1449.  
  1450.   /* Length of pending accumulated identifier.  */
  1451.   register int ident_length = 0;
  1452.  
  1453.   /* Hash code of pending accumulated identifier.  */
  1454.   register int hash = 0;
  1455.  
  1456.   /* Current input level (&instack[indepth]).  */
  1457.   FILE_BUF *ip;
  1458.  
  1459.   /* Pointer for scanning input.  */
  1460.   register U_CHAR *ibp;
  1461.  
  1462.   /* Pointer to end of input.  End of scan is controlled by LIMIT.  */
  1463.   register U_CHAR *limit;
  1464.  
  1465.   /* Pointer for storing output.  */
  1466.   register U_CHAR *obp;
  1467.  
  1468.   /* REDO_CHAR is nonzero if we are processing an identifier
  1469.      after backing up over the terminating character.
  1470.      Sometimes we process an identifier without backing up over
  1471.      the terminating character, if the terminating character
  1472.      is not special.  Backing up is done so that the terminating character
  1473.      will be dispatched on again once the identifier is dealt with.  */
  1474.   int redo_char = 0;
  1475.  
  1476.   /* 1 if within an identifier inside of which a concatenation
  1477.      marker (Newline -) has been seen.  */
  1478.   int concatenated = 0;
  1479.  
  1480.   /* While scanning a comment or a string constant,
  1481.      this records the line it started on, for error messages.  */
  1482.   int start_line;
  1483.  
  1484.   /* Record position of last `real' newline.  */
  1485.   U_CHAR *beg_of_line;
  1486.  
  1487. /* Pop the innermost input stack level, assuming it is a macro expansion.  */
  1488.  
  1489. #define POPMACRO \
  1490. do { ip->macro->type = T_MACRO;        \
  1491.      if (ip->free_ptr) free (ip->free_ptr);    \
  1492.      --indepth; } while (0)
  1493.  
  1494. /* Reload `rescan's local variables that describe the current
  1495.    level of the input stack.  */
  1496.  
  1497. #define RECACHE  \
  1498. do { ip = &instack[indepth];        \
  1499.      ibp = ip->bufp;            \
  1500.      limit = ip->buf + ip->length;    \
  1501.      op->bufp = obp;            \
  1502.      check_expand (op, limit - ibp);    \
  1503.      beg_of_line = 0;            \
  1504.      obp = op->bufp; } while (0)
  1505.  
  1506.   if (no_output && instack[indepth].fname != 0)
  1507.     skip_if_group (&instack[indepth], 1);
  1508.  
  1509.   obp = op->bufp;
  1510.   RECACHE;
  1511.   beg_of_line = ibp;
  1512.  
  1513.   /* Our caller must always put a null after the end of
  1514.      the input at each input stack level.  */
  1515.   if (*limit != 0)
  1516.     abort ();
  1517.  
  1518.   while (1) {
  1519.     c = *ibp++;
  1520.     *obp++ = c;
  1521.  
  1522.     switch (c) {
  1523.     case '\\':
  1524.       if (ibp >= limit)
  1525.     break;
  1526.       if (*ibp == '\n') {
  1527.     /* Always merge lines ending with backslash-newline,
  1528.        even in middle of identifier.  */
  1529.     ++ibp;
  1530.     ++ip->lineno;
  1531.     --obp;        /* remove backslash from obuf */
  1532.     break;
  1533.       }
  1534.       /* Otherwise, backslash suppresses specialness of following char,
  1535.      so copy it here to prevent the switch from seeing it.
  1536.      But first get any pending identifier processed.  */
  1537.       if (ident_length > 0)
  1538.     goto specialchar;
  1539.       *obp++ = *ibp++;
  1540.       break;
  1541.  
  1542.     case '#':
  1543.       /* If this is expanding a macro definition, don't recognize
  1544.      preprocessor directives.  */
  1545.       if (ip->macro != 0)
  1546.     goto randomchar;
  1547.       if (ident_length)
  1548.     goto specialchar;
  1549.  
  1550.       /* # keyword: a # must be first nonblank char on the line */
  1551.       if (beg_of_line == 0)
  1552.     goto randomchar;
  1553.       {
  1554.     U_CHAR *bp;
  1555.  
  1556.     /* Scan from start of line, skipping whitespace, comments
  1557.        and backslash-newlines, and see if we reach this #.
  1558.        If not, this # is not special.  */
  1559.     bp = beg_of_line;
  1560.     while (1) {
  1561.       if (is_hor_space[*bp])
  1562.         bp++;
  1563.       else if (*bp == '\\' && bp[1] == '\n')
  1564.         bp += 2;
  1565.       else if (*bp == '/' && bp[1] == '*') {
  1566.         bp += 2;
  1567.         while (!(*bp == '*' && bp[1] == '/'))
  1568.           bp++;
  1569.         bp += 2;
  1570.       }
  1571.       else if (cplusplus && *bp == '/' && bp[1] == '/') {
  1572.         bp += 2;
  1573.         while (*bp++ != '\n') ;
  1574.       }
  1575.       else break;
  1576.     }
  1577.     if (bp + 1 != ibp)
  1578.       goto randomchar;
  1579.       }
  1580.  
  1581.       /* This # can start a directive.  */
  1582.  
  1583.       --obp;        /* Don't copy the '#' */
  1584.  
  1585.       ip->bufp = ibp;
  1586.       op->bufp = obp;
  1587.       if (! handle_directive (ip, op)) {
  1588. #ifdef USE_C_ALLOCA
  1589.     alloca (0);
  1590. #endif
  1591.     /* Not a known directive: treat it as ordinary text.
  1592.        IP, OP, IBP, etc. have not been changed.  */
  1593.     if (no_output && instack[indepth].fname) {
  1594.       /* If not generating expanded output,
  1595.          what we do with ordinary text is skip it.
  1596.          Discard everything until next # directive.  */
  1597.       skip_if_group (&instack[indepth], 1);
  1598.       RECACHE;
  1599.       beg_of_line = ibp;
  1600.       break;
  1601.     }
  1602.     ++obp;        /* Copy the '#' after all */
  1603.     goto randomchar;
  1604.       }
  1605. #ifdef USE_C_ALLOCA
  1606.       alloca (0);
  1607. #endif
  1608.       /* A # directive has been successfully processed.  */
  1609.       /* If not generating expanded output, ignore everything until
  1610.      next # directive.  */
  1611.       if (no_output && instack[indepth].fname)
  1612.     skip_if_group (&instack[indepth], 1);
  1613.       obp = op->bufp;
  1614.       RECACHE;
  1615.       beg_of_line = ibp;
  1616.       break;
  1617.  
  1618.     case '\"':            /* skip quoted string */
  1619.     case '\'':
  1620.       /* A single quoted string is treated like a double -- some
  1621.      programs (e.g., troff) are perverse this way */
  1622.  
  1623.       if (ident_length)
  1624.     goto specialchar;
  1625.  
  1626.       start_line = ip->lineno;
  1627.  
  1628.       /* Skip ahead to a matching quote.  */
  1629.  
  1630.       while (1) {
  1631.     if (ibp >= limit) {
  1632.       if (traditional) {
  1633.         if (ip->macro != 0) {
  1634.           /* try harder: this string crosses a macro expansion boundary */
  1635.           POPMACRO;
  1636.           RECACHE;
  1637.           continue;
  1638.         }
  1639.       } else
  1640.         error_with_line (line_for_error (start_line),
  1641.                  "unterminated string or character constant");
  1642.       break;
  1643.     }
  1644.     *obp++ = *ibp;
  1645.     switch (*ibp++) {
  1646.     case '\n':
  1647.       ++ip->lineno;
  1648.       ++op->lineno;
  1649.       /* Traditionally, end of line ends a string constant with no error.
  1650.          So exit the loop and record the new line.  */
  1651.       if (traditional) {
  1652.         beg_of_line = ibp;
  1653.         goto while2end;
  1654.       }
  1655.       if (pedantic || c == '\'') {
  1656.         error_with_line (line_for_error (start_line),
  1657.                  "unterminated string or character constant");
  1658.         goto while2end;
  1659.       }
  1660.       break;
  1661.  
  1662.     case '\\':
  1663.       if (ibp >= limit)
  1664.         break;
  1665.       if (*ibp == '\n') {
  1666.         /* Backslash newline is replaced by nothing at all,
  1667.            but keep the line counts correct.  */
  1668.         --obp;
  1669.         ++ibp;
  1670.         ++ip->lineno;
  1671.       } else {
  1672.         /* ANSI stupidly requires that in \\ the second \
  1673.            is *not* prevented from combining with a newline.  */
  1674.         while (*ibp == '\\' && ibp[1] == '\n') {
  1675.           ibp += 2;
  1676.           ++ip->lineno;
  1677.         }
  1678.         *obp++ = *ibp++;
  1679.       }
  1680.       break;
  1681.  
  1682.     case '\"':
  1683.     case '\'':
  1684.       if (ibp[-1] == c)
  1685.         goto while2end;
  1686.       break;
  1687.     }
  1688.       }
  1689.     while2end:
  1690.       break;
  1691.  
  1692.     case '/':
  1693.       if (*ibp == '\\' && ibp[1] == '\n')
  1694.     newline_fix (ibp);
  1695.       if (cplusplus && *ibp == '/') {
  1696.     /* C++ style comment... */
  1697.     start_line = ip->lineno;
  1698.  
  1699.     --ibp;            /* Back over the slash */
  1700.     --obp;
  1701.  
  1702.     /* Comments are equivalent to spaces. */
  1703.     if (! put_out_comments)
  1704.       *obp++ = ' ';
  1705.     else {
  1706.       /* must fake up a comment here */
  1707.       *obp++ = '/';
  1708.       *obp++ = '/';
  1709.     }
  1710.     {
  1711.       U_CHAR *before_bp = ibp+2;
  1712.  
  1713.       while (ibp < limit) {
  1714.         if (*ibp++ == '\n') {
  1715.           ibp--;
  1716.           if (put_out_comments) {
  1717.         bcopy (before_bp, obp, ibp - before_bp);
  1718.         obp += ibp - before_bp;
  1719.           }
  1720.           break;
  1721.         }
  1722.       }
  1723.       break;
  1724.     }
  1725.       }
  1726.       if (*ibp != '*')
  1727.     goto randomchar;
  1728.       if (ip->macro != 0)
  1729.     goto randomchar;
  1730.       if (ident_length)
  1731.     goto specialchar;
  1732.  
  1733.       /* We have a comment.  Skip it, optionally copying it to output.  */
  1734.  
  1735.       start_line = ip->lineno;
  1736.  
  1737.       ++ibp;            /* Skip the star. */
  1738.  
  1739.       /* Comments are equivalent to spaces.
  1740.      Note that we already output the slash; we might not want it.
  1741.      For -traditional, a comment is equivalent to nothing.  */
  1742.       if (! put_out_comments) {
  1743.     if (traditional)
  1744.       obp--;
  1745.     else
  1746.       obp[-1] = ' ';
  1747.       }
  1748.       else
  1749.     *obp++ = '*';
  1750.  
  1751.       {
  1752.     U_CHAR *before_bp = ibp;
  1753.  
  1754.     while (ibp < limit) {
  1755.       switch (*ibp++) {
  1756.       case '/':
  1757.         if (warn_comments && ibp < limit && *ibp == '*')
  1758.           warning("`/*' within comment");
  1759.         break;
  1760.       case '*':
  1761.         if (*ibp == '\\' && ibp[1] == '\n')
  1762.           newline_fix (ibp);
  1763.         if (ibp >= limit || *ibp == '/')
  1764.           goto comment_end;
  1765.         break;
  1766.       case '\n':
  1767.         ++ip->lineno;
  1768.         /* Copy the newline into the output buffer, in order to
  1769.            avoid the pain of a #line every time a multiline comment
  1770.            is seen.  */
  1771.         if (!put_out_comments)
  1772.           *obp++ = '\n';
  1773.         ++op->lineno;
  1774.       }
  1775.     }
  1776.       comment_end:
  1777.  
  1778.     if (ibp >= limit)
  1779.       error_with_line (line_for_error (start_line),
  1780.                "unterminated comment");
  1781.     else {
  1782.       ibp++;
  1783.       if (put_out_comments) {
  1784.         bcopy (before_bp, obp, ibp - before_bp);
  1785.         obp += ibp - before_bp;
  1786.       }
  1787.     }
  1788.       }
  1789.       break;
  1790.  
  1791.     case '$':
  1792.       if (!dollars_in_ident)
  1793.     goto randomchar;
  1794.       goto letter;
  1795.  
  1796.     case '0': case '1': case '2': case '3': case '4':
  1797.     case '5': case '6': case '7': case '8': case '9':
  1798.       /* If digit is not part of identifier, it starts a number,
  1799.      which means that following letters are not an identifier.
  1800.      "0x5" does not refer to an identifier "x5".
  1801.      So copy all alphanumerics that follow without accumulating
  1802.      as an identifier.  Periods also, for sake of "3.e7".  */
  1803.  
  1804.       if (ident_length == 0) {
  1805.     while (ibp < limit) {
  1806.       c = *ibp++;
  1807.       if (!isalnum (c) && c != '.' && c != '_') {
  1808.         --ibp;
  1809.         break;
  1810.       }
  1811.       *obp++ = c;
  1812.       /* A sign can be part of a preprocessing number
  1813.          if it follows an e.  */
  1814.       if (c == 'e' || c == 'E') {
  1815.         if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
  1816.           *obp++ = *ibp++;
  1817.           /* But traditional C does not let the token go past the sign.  */
  1818.           if (traditional)
  1819.         break;
  1820.         }
  1821.       }
  1822.     }
  1823.     break;
  1824.       }
  1825.       /* fall through */
  1826.  
  1827.     case '_':
  1828.     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
  1829.     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
  1830.     case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
  1831.     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
  1832.     case 'y': case 'z':
  1833.     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  1834.     case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
  1835.     case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
  1836.     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
  1837.     case 'Y': case 'Z':
  1838.     letter:
  1839.       ident_length++;
  1840.       /* Compute step of hash function, to avoid a proc call on every token */
  1841.       hash = HASHSTEP (hash, c);
  1842.       break;
  1843.  
  1844.     case '\n':
  1845.       /* If reprocessing a macro expansion, newline is a special marker.  */
  1846.       if (ip->macro != 0) {
  1847.     /* Newline White is a "funny space" to separate tokens that are
  1848.        supposed to be separate but without space between.
  1849.        Here White means any horizontal whitespace character.
  1850.        Newline - marks a recursive macro use that is not
  1851.        supposed to be expandable.  */
  1852.  
  1853.     if (*ibp == '-') {
  1854.       /* Newline - inhibits expansion of preceding token.
  1855.          If expanding a macro arg, we keep the newline -.
  1856.          In final output, it is deleted.  */
  1857.       if (! concatenated) {
  1858.         ident_length = 0;
  1859.         hash = 0;
  1860.       }
  1861.       ibp++;
  1862.       if (!output_marks) {
  1863.         obp--;
  1864.       } else {
  1865.         /* If expanding a macro arg, keep the newline -.  */
  1866.         *obp++ = '-';
  1867.       }
  1868.     } else if (is_space[*ibp]) {
  1869.       /* Newline Space does not prevent expansion of preceding token
  1870.          so expand the preceding token and then come back.  */
  1871.       if (ident_length > 0)
  1872.         goto specialchar;
  1873.  
  1874.       /* If generating final output, newline space makes a space.  */
  1875.       if (!output_marks) {
  1876.         obp[-1] = *ibp++;
  1877.         /* And Newline Newline makes a newline, so count it.  */
  1878.         if (obp[-1] == '\n')
  1879.           op->lineno++;
  1880.       } else {
  1881.         /* If expanding a macro arg, keep the newline space.
  1882.            If the arg gets stringified, newline space makes nothing.  */
  1883.         *obp++ = *ibp++;
  1884.       }
  1885.     } else abort ();    /* Newline followed by something random?  */
  1886.     break;
  1887.       }
  1888.  
  1889.       /* If there is a pending identifier, handle it and come back here.  */
  1890.       if (ident_length > 0)
  1891.     goto specialchar;
  1892.  
  1893.       beg_of_line = ibp;
  1894.  
  1895.       /* Update the line counts and output a #line if necessary.  */
  1896.       ++ip->lineno;
  1897.       ++op->lineno;
  1898.       if (ip->lineno != op->lineno) {
  1899.     op->bufp = obp;
  1900.     output_line_command (ip, op, 1, same_file);
  1901.     check_expand (op, ip->length - (ip->bufp - ip->buf));
  1902.     obp = op->bufp;
  1903.       }
  1904.       break;
  1905.  
  1906.       /* Come here either after (1) a null character that is part of the input
  1907.      or (2) at the end of the input, because there is a null there.  */
  1908.     case 0:
  1909.       if (ibp <= limit)
  1910.     /* Our input really contains a null character.  */
  1911.     goto randomchar;
  1912.  
  1913.       /* At end of a macro-expansion level, pop it and read next level.  */
  1914.       if (ip->macro != 0) {
  1915.     obp--;
  1916.     ibp--;
  1917.     /* If traditional, and we have an identifier that ends here,
  1918.        process it now, so we get the right error for recursion.  */
  1919.     if (traditional && ident_length
  1920.         && ! is_idchar[*instack[indepth - 1].bufp]) {
  1921.       redo_char = 1;
  1922.       goto randomchar;
  1923.     }
  1924.     POPMACRO;
  1925.     RECACHE;
  1926.     break;
  1927.       }
  1928.  
  1929.       /* If we don't have a pending identifier,
  1930.      return at end of input.  */
  1931.       if (ident_length == 0) {
  1932.     obp--;
  1933.     ibp--;
  1934.     op->bufp = obp;
  1935.     ip->bufp = ibp;
  1936.     goto ending;
  1937.       }
  1938.  
  1939.       /* If we do have a pending identifier, just consider this null
  1940.      a special character and arrange to dispatch on it again.
  1941.      The second time, IDENT_LENGTH will be zero so we will return.  */
  1942.  
  1943.       /* Fall through */
  1944.  
  1945. specialchar:
  1946.  
  1947.       /* Handle the case of a character such as /, ', " or null
  1948.      seen following an identifier.  Back over it so that
  1949.      after the identifier is processed the special char
  1950.      will be dispatched on again.  */
  1951.  
  1952.       ibp--;
  1953.       obp--;
  1954.       redo_char = 1;
  1955.  
  1956.     default:
  1957.  
  1958. randomchar:
  1959.  
  1960.       if (ident_length > 0) {
  1961.     register HASHNODE *hp;
  1962.  
  1963.     /* We have just seen an identifier end.  If it's a macro, expand it.
  1964.  
  1965.        IDENT_LENGTH is the length of the identifier
  1966.        and HASH is its hash code.
  1967.  
  1968.        The identifier has already been copied to the output,
  1969.        so if it is a macro we must remove it.
  1970.  
  1971.        If REDO_CHAR is 0, the char that terminated the identifier
  1972.        has been skipped in the output and the input.
  1973.        OBP-IDENT_LENGTH-1 points to the identifier.
  1974.        If the identifier is a macro, we must back over the terminator.
  1975.  
  1976.        If REDO_CHAR is 1, the terminating char has already been
  1977.        backed over.  OBP-IDENT_LENGTH points to the identifier.  */
  1978.  
  1979.     for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
  1980.          hp = hp->next) {
  1981.  
  1982.       if (hp->length == ident_length) {
  1983.         U_CHAR *obufp_before_macroname;
  1984.         int op_lineno_before_macroname;
  1985.         register int i = ident_length;
  1986.         register U_CHAR *p = hp->name;
  1987.         register U_CHAR *q = obp - i;
  1988.         int disabled;
  1989.  
  1990.         if (! redo_char)
  1991.           q--;
  1992.  
  1993.         do {        /* All this to avoid a strncmp () */
  1994.           if (*p++ != *q++)
  1995.         goto hashcollision;
  1996.         } while (--i);
  1997.  
  1998.         /* We found a use of a macro name.
  1999.            see if the context shows it is a macro call.  */
  2000.  
  2001.         /* Back up over terminating character if not already done.  */
  2002.         if (! redo_char) {
  2003.           ibp--;
  2004.           obp--;
  2005.         }
  2006.  
  2007.         obufp_before_macroname = obp - ident_length;
  2008.         op_lineno_before_macroname = op->lineno;
  2009.  
  2010.         /* Record whether the macro is disabled.  */
  2011.         disabled = hp->type == T_DISABLED;
  2012.  
  2013.         /* This looks like a macro ref, but if the macro was disabled,
  2014.            just copy its name and put in a marker if requested.  */
  2015.  
  2016.         if (disabled) {
  2017. #if 0
  2018.           /* This error check caught useful cases such as
  2019.          #define foo(x,y) bar(x(y,0), y)
  2020.          foo(foo, baz)  */
  2021.           if (traditional)
  2022.         error ("recursive use of macro `%s'", hp->name );
  2023. #endif
  2024.  
  2025.           if (output_marks) {
  2026.         check_expand (op, limit - ibp + 2);
  2027.         *obp++ = '\n';
  2028.         *obp++ = '-';
  2029.           }
  2030.           break;
  2031.         }
  2032.  
  2033.         /* If macro wants an arglist, verify that a '(' follows.
  2034.            first skip all whitespace, copying it to the output
  2035.            after the macro name.  Then, if there is no '(',
  2036.            decide this is not a macro call and leave things that way.  */
  2037.         if ((hp->type == T_MACRO || hp->type == T_DISABLED)
  2038.         && hp->value.defn->nargs >= 0)
  2039.           {
  2040.         while (1) {
  2041.           /* Scan forward over whitespace, copying it to the output.  */
  2042.           if (ibp == limit && ip->macro != 0) {
  2043.             POPMACRO;
  2044.             RECACHE;
  2045.           }
  2046.           /* A comment: copy it unchanged or discard it.  */
  2047.           else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
  2048.             if (put_out_comments) {
  2049.               *obp++ = '/';
  2050.               *obp++ = '*';
  2051.             } else if (! traditional) {
  2052.               *obp++ = ' ';
  2053.             }
  2054.             ibp += 2;
  2055.             while (ibp + 1 != limit
  2056.                && !(ibp[0] == '*' && ibp[1] == '/')) {
  2057.               /* We need not worry about newline-marks,
  2058.              since they are never found in comments.  */
  2059.               if (*ibp == '\n') {
  2060.             /* Newline in a file.  Count it.  */
  2061.             ++ip->lineno;
  2062.             ++op->lineno;
  2063.               }
  2064.               if (put_out_comments)
  2065.             *obp++ = *ibp++;
  2066.               else
  2067.             ibp++;
  2068.             }
  2069.             ibp += 2;
  2070.             if (put_out_comments) {
  2071.               *obp++ = '*';
  2072.               *obp++ = '/';
  2073.             }
  2074.           }
  2075.           else if (is_space[*ibp]) {
  2076.             *obp++ = *ibp++;
  2077.             if (ibp[-1] == '\n') {
  2078.               if (ip->macro == 0) {
  2079.             /* Newline in a file.  Count it.  */
  2080.             ++ip->lineno;
  2081.             ++op->lineno;
  2082.               } else if (!output_marks) {
  2083.             /* A newline mark, and we don't want marks
  2084.                in the output.  If it is newline-hyphen,
  2085.                discard it entirely.  Otherwise, it is
  2086.                newline-whitechar, so keep the whitechar.  */
  2087.             obp--;
  2088.             if (*ibp == '-')
  2089.               ibp++;
  2090.             else {
  2091.               if (*ibp == '\n')
  2092.                 ++op->lineno;
  2093.               *obp++ = *ibp++;
  2094.             }
  2095.               } else {
  2096.             /* A newline mark; copy both chars to the output.  */
  2097.             *obp++ = *ibp++;
  2098.               }
  2099.             }
  2100.           }
  2101.           else break;
  2102.         }
  2103.         if (*ibp != '(')
  2104.           break;
  2105.           }
  2106.  
  2107.         /* This is now known to be a macro call.
  2108.            Discard the macro name from the output,
  2109.            along with any following whitespace just copied.  */
  2110.         obp = obufp_before_macroname;
  2111.         op->lineno = op_lineno_before_macroname;
  2112.  
  2113.         /* Expand the macro, reading arguments as needed,
  2114.            and push the expansion on the input stack.  */
  2115.         ip->bufp = ibp;
  2116.         op->bufp = obp;
  2117.         macroexpand (hp, op);
  2118.  
  2119.         /* Reexamine input stack, since macroexpand has pushed
  2120.            a new level on it.  */
  2121.         obp = op->bufp;
  2122.         RECACHE;
  2123.         break;
  2124.       }
  2125. hashcollision:
  2126.            ;
  2127.     }            /* End hash-table-search loop */
  2128.     ident_length = hash = 0; /* Stop collecting identifier */
  2129.     redo_char = 0;
  2130.     concatenated = 0;
  2131.       }                /* End if (ident_length > 0) */
  2132.     }                /* End switch */
  2133.   }                /* End per-char loop */
  2134.  
  2135.   /* Come here to return -- but first give an error message
  2136.      if there was an unterminated successful conditional.  */
  2137.  ending:
  2138.   if (if_stack != ip->if_stack) {
  2139.     char *str;
  2140.     switch (if_stack->type) {
  2141.     case T_IF:
  2142.       str = "if";
  2143.       break;
  2144.     case T_IFDEF:
  2145.       str = "ifdef";
  2146.       break;
  2147.     case T_IFNDEF:
  2148.       str = "ifndef";
  2149.       break;
  2150.     case T_ELSE:
  2151.       str = "else";
  2152.       break;
  2153.     case T_ELIF:
  2154.       str = "elif";
  2155.       break;
  2156.     }
  2157.     error_with_line (line_for_error (if_stack->lineno),
  2158.              "unterminated #%s conditional", str);
  2159.   }
  2160.   if_stack = ip->if_stack;
  2161. }
  2162.  
  2163. /*
  2164.  * Rescan a string into a temporary buffer and return the result
  2165.  * as a FILE_BUF.  Note this function returns a struct, not a pointer.
  2166.  *
  2167.  * OUTPUT_MARKS nonzero means keep Newline markers found in the input
  2168.  * and insert such markers when appropriate.  See `rescan' for details.
  2169.  * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
  2170.  * before substitution; it is 0 for other uses.
  2171.  */
  2172. FILE_BUF
  2173. expand_to_temp_buffer (buf, limit, output_marks)
  2174.      U_CHAR *buf, *limit;
  2175.      int output_marks;
  2176. {
  2177.   register FILE_BUF *ip;
  2178.   FILE_BUF obuf;
  2179.   int length = limit - buf;
  2180.   U_CHAR *buf1;
  2181.   int odepth = indepth;
  2182.  
  2183.   if (length < 0)
  2184.     abort ();
  2185.  
  2186.   /* Set up the input on the input stack.  */
  2187.  
  2188.   buf1 = (U_CHAR *) alloca (length + 1);
  2189.   {
  2190.     register U_CHAR *p1 = buf;
  2191.     register U_CHAR *p2 = buf1;
  2192.  
  2193.     while (p1 != limit)
  2194.       *p2++ = *p1++;
  2195.   }
  2196.   buf1[length] = 0;
  2197.  
  2198.   /* Set up to receive the output.  */
  2199.  
  2200.   obuf.length = length * 2 + 100; /* Usually enough.  Why be stingy?  */
  2201.   obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
  2202.   obuf.fname = 0;
  2203.   obuf.macro = 0;
  2204.   obuf.free_ptr = 0;
  2205.  
  2206.   CHECK_DEPTH ({return obuf;});
  2207.  
  2208.   ++indepth;
  2209.  
  2210.   ip = &instack[indepth];
  2211.   ip->fname = 0;
  2212.   ip->macro = 0;
  2213.   ip->free_ptr = 0;
  2214.   ip->length = length;
  2215.   ip->buf = ip->bufp = buf1;
  2216.   ip->if_stack = if_stack;
  2217.  
  2218.   ip->lineno = obuf.lineno = 1;
  2219.  
  2220.   /* Scan the input, create the output.  */
  2221.  
  2222.   rescan (&obuf, output_marks);
  2223.  
  2224.   /* Pop input stack to original state.  */
  2225.   --indepth;
  2226.  
  2227.   if (indepth != odepth)
  2228.     abort ();
  2229.  
  2230.   /* Record the output.  */
  2231.   obuf.length = obuf.bufp - obuf.buf;
  2232.  
  2233.   return obuf;
  2234. }
  2235.  
  2236. /*
  2237.  * Process a # directive.  Expects IP->bufp to point to the '#', as in
  2238.  * `#define foo bar'.  Passes to the command handler
  2239.  * (do_define, do_include, etc.): the addresses of the 1st and
  2240.  * last chars of the command (starting immediately after the #
  2241.  * keyword), plus op and the keyword table pointer.  If the command
  2242.  * contains comments it is copied into a temporary buffer sans comments
  2243.  * and the temporary buffer is passed to the command handler instead.
  2244.  * Likewise for backslash-newlines.
  2245.  *
  2246.  * Returns nonzero if this was a known # directive.
  2247.  * Otherwise, returns zero, without advancing the input pointer.
  2248.  */
  2249.  
  2250. int
  2251. handle_directive (ip, op)
  2252.      FILE_BUF *ip, *op;
  2253. {
  2254.   register U_CHAR *bp, *cp;
  2255.   register struct directive *kt;
  2256.   register int ident_length;
  2257.   U_CHAR *resume_p;
  2258.  
  2259.   /* Nonzero means we must copy the entire command
  2260.      to get rid of comments or backslash-newlines.  */
  2261.   int copy_command = 0;
  2262.  
  2263.   U_CHAR *ident, *after_ident;
  2264.  
  2265.   bp = ip->bufp;
  2266.   /* Skip whitespace and \-newline.  */
  2267.   while (1) {
  2268.     if (is_hor_space[*bp])
  2269.       bp++;
  2270.     else if (*bp == '/' && bp[1] == '*') {
  2271.       ip->bufp = bp;
  2272.       skip_to_end_of_comment (ip, &ip->lineno);
  2273.       bp = ip->bufp;
  2274.     } else if (*bp == '\\' && bp[1] == '\n') {
  2275.       bp += 2; ip->lineno++;
  2276.     } else break;
  2277.   }
  2278.  
  2279.   /* Now find end of directive name.
  2280.      If we encounter a backslash-newline, exchange it with any following
  2281.      symbol-constituents so that we end up with a contiguous name.  */
  2282.  
  2283.   cp = bp;
  2284.   while (1) {
  2285.     if (is_idchar[*cp])
  2286.       cp++;
  2287.     else {
  2288.       if (*cp == '\\' && cp[1] == '\n')
  2289.     name_newline_fix (cp);
  2290.       if (is_idchar[*cp])
  2291.     cp++;
  2292.       else break;
  2293.     }
  2294.   }
  2295.   ident_length = cp - bp;
  2296.   ident = bp;
  2297.   after_ident = cp;
  2298.  
  2299.   /* A line of just `#' becomes blank.  */
  2300.  
  2301.   if (traditional && ident_length == 0 && *after_ident == '\n') {
  2302.     ip->bufp = after_ident;
  2303.     return 1;
  2304.   }
  2305.  
  2306.   /*
  2307.    * Decode the keyword and call the appropriate expansion
  2308.    * routine, after moving the input pointer up to the next line.
  2309.    */
  2310.   for (kt = directive_table; kt->length > 0; kt++) {
  2311. #if defined( NeXT )
  2312.     if (kt->length == ident_length && !strncmp (kt->name, (char *) ident, ident_length)) {
  2313. #else
  2314.     if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length)) {
  2315. #endif
  2316.       register U_CHAR *buf;
  2317.       register U_CHAR *limit = ip->buf + ip->length;
  2318.       int unterminated = 0;
  2319.  
  2320.       /* Nonzero means do not delete comments within the directive.
  2321.      #define needs this when -traditional.  */
  2322.       int keep_comments = traditional && kt->traditional_comments;
  2323.  
  2324.       /* Find the end of this command (first newline not backslashed
  2325.      and not in a string or comment).
  2326.      Set COPY_COMMAND if the command must be copied
  2327.      (it contains a backslash-newline or a comment).  */
  2328.  
  2329.       buf = bp = after_ident;
  2330.       while (bp < limit) {
  2331.     register U_CHAR c = *bp++;
  2332.     switch (c) {
  2333.     case '\\':
  2334.       if (bp < limit) {
  2335.         if (*bp == '\n') {
  2336.           ip->lineno++;
  2337.           copy_command = 1;
  2338.         }
  2339.         bp++;
  2340.       }
  2341.       break;
  2342.  
  2343.     case '\'':
  2344.     case '\"':
  2345.       bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_command, &unterminated);
  2346.       /* Don't bother calling the directive if we already got an error
  2347.          message due to unterminated string.  Skip everything and pretend
  2348.          we called the directive.  */
  2349.       if (unterminated) {
  2350.         if (traditional) {
  2351.           /* Traditional preprocessing permits unterminated strings.  */
  2352.           ip->bufp = bp;
  2353.           goto endloop1;
  2354.         }
  2355.         ip->bufp = bp;
  2356.         return 1;
  2357.       }
  2358.       break;
  2359.  
  2360.       /* <...> is special for #include.  */
  2361.     case '<':
  2362.       if (!kt->angle_brackets)
  2363.         break;
  2364.       while (*bp && *bp != '>') bp++;
  2365.       break;
  2366.  
  2367.     case '/':
  2368.       if (*bp == '\\' && bp[1] == '\n')
  2369.         newline_fix (bp);
  2370.       if (*bp == '*'
  2371.           || (cplusplus && *bp == '/')) {
  2372.         U_CHAR *obp = bp - 1;
  2373.         ip->bufp = bp + 1;
  2374.         skip_to_end_of_comment (ip, &ip->lineno);
  2375.         bp = ip->bufp;
  2376.         /* No need to copy the command because of a comment at the end;
  2377.            just don't include the comment in the directive.  */
  2378.         if (bp == limit || *bp == '\n') {
  2379.           bp = obp;
  2380.           goto endloop1;
  2381.         }
  2382.         /* Don't remove the comments if -traditional.  */
  2383.         if (! keep_comments)
  2384.           copy_command++;
  2385.       }
  2386.       break;
  2387.  
  2388.     case '\n':
  2389.       --bp;        /* Point to the newline */
  2390.       ip->bufp = bp;
  2391.       goto endloop1;
  2392.     }
  2393.       }
  2394.       ip->bufp = bp;
  2395.  
  2396.     endloop1:
  2397.       resume_p = ip->bufp;
  2398.       /* BP is the end of the directive.
  2399.      RESUME_P is the next interesting data after the directive.
  2400.      A comment may come between.  */
  2401.  
  2402.       if (copy_command) {
  2403.     register U_CHAR *xp = buf;
  2404.     /* Need to copy entire command into temp buffer before dispatching */
  2405.  
  2406.     cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
  2407.                           some slop */
  2408.     buf = cp;
  2409.  
  2410.     /* Copy to the new buffer, deleting comments
  2411.        and backslash-newlines (and whitespace surrounding the latter).  */
  2412.  
  2413.     while (xp < bp) {
  2414.       register U_CHAR c = *xp++;
  2415.       *cp++ = c;
  2416.  
  2417.       switch (c) {
  2418.       case '\n':
  2419.         break;
  2420.  
  2421.         /* <...> is special for #include.  */
  2422.       case '<':
  2423.         if (!kt->angle_brackets)
  2424.           break;
  2425.         while (xp < bp && c != '>') {
  2426.           c = *xp++;
  2427.           *cp++ = c;
  2428.         }
  2429.         break;
  2430.  
  2431.       case '\\':
  2432.         if (*xp == '\n') {
  2433.           xp++;
  2434.           cp--;
  2435.           if (cp != buf && is_space[cp[-1]]) {
  2436.         while (cp != buf && is_space[cp[-1]]) cp--;
  2437.         cp++;
  2438.         SKIP_WHITE_SPACE (xp);
  2439.           } else if (is_space[*xp]) {
  2440.         *cp++ = *xp++;
  2441.         SKIP_WHITE_SPACE (xp);
  2442.           }
  2443.         }
  2444.         break;
  2445.  
  2446.       case '\'':
  2447.       case '\"':
  2448.         {
  2449.           register U_CHAR *bp1
  2450.         = skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
  2451.           while (xp != bp1)
  2452.         *cp++ = *xp++;
  2453.         }
  2454.         break;
  2455.  
  2456.       case '/':
  2457.         if (*xp == '*'
  2458.         || (cplusplus && *xp == '/')) {
  2459.           ip->bufp = xp + 1;
  2460.           skip_to_end_of_comment (ip, 0);
  2461.           if (keep_comments)
  2462.         while (xp != ip->bufp)
  2463.           *cp++ = *xp++;
  2464.           /* Delete or replace the slash.  */
  2465.           else if (traditional)
  2466.         cp--;
  2467.           else
  2468.         cp[-1] = ' ';
  2469.           xp = ip->bufp;
  2470.         }
  2471.       }
  2472.     }
  2473.  
  2474.     /* Null-terminate the copy.  */
  2475.  
  2476.     *cp = 0;
  2477.       }
  2478.       else
  2479.     cp = bp;
  2480.  
  2481.       ip->bufp = resume_p;
  2482.  
  2483.       /* Some directives should be written out for cc1 to process,
  2484.      just as if they were not defined.  */
  2485.  
  2486.       if (kt->pass_thru) {
  2487.         int len;
  2488.  
  2489.     /* Output directive name.  */
  2490.         check_expand (op, kt->length+1);
  2491.         *op->bufp++ = '#';
  2492.         bcopy (kt->name, op->bufp, kt->length);
  2493.         op->bufp += kt->length;
  2494.  
  2495.     /* Output arguments.  */
  2496.         len = (cp - buf);
  2497.         check_expand (op, len);
  2498.         bcopy (buf, op->bufp, len);
  2499.         op->bufp += len;
  2500.       }
  2501.  
  2502.       /* Call the appropriate command handler.  buf now points to
  2503.      either the appropriate place in the input buffer, or to
  2504.      the temp buffer if it was necessary to make one.  cp
  2505.      points to the first char after the contents of the (possibly
  2506.      copied) command, in either case. */
  2507.       (*kt->func) (buf, cp, op, kt);
  2508.       check_expand (op, ip->length - (ip->bufp - ip->buf));
  2509.  
  2510.       return 1;
  2511.     }
  2512.   }
  2513.  
  2514.   return 0;
  2515. }
  2516.  
  2517. static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  2518.                  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
  2519.                 };
  2520.  
  2521. /*
  2522.  * expand things like __FILE__.  Place the expansion into the output
  2523.  * buffer *without* rescanning.
  2524.  */
  2525. special_symbol (hp, op)
  2526.      HASHNODE *hp;
  2527.      FILE_BUF *op;
  2528. {
  2529.   char *buf;
  2530.   long t;
  2531.   int i, len;
  2532.   int true_indepth;
  2533.   FILE_BUF *ip = NULL;
  2534.   static struct tm *timebuf = NULL;
  2535.   struct tm *localtime ();
  2536.  
  2537.   int paren = 0;        /* For special `defined' keyword */
  2538.  
  2539.   for (i = indepth; i >= 0; i--)
  2540.     if (instack[i].fname != NULL) {
  2541.       ip = &instack[i];
  2542.       break;
  2543.     }
  2544.   if (ip == NULL) {
  2545.     error ("cccp error: not in any file?!");
  2546.     return;            /* the show must go on */
  2547.   }
  2548.  
  2549.   switch (hp->type) {
  2550.   case T_FILE:
  2551.   case T_BASE_FILE:
  2552.     {
  2553.       char *string;
  2554.       if (hp->type == T_FILE)
  2555.     string = ip->fname;
  2556.       else
  2557.     string = instack[0].fname;
  2558.  
  2559.       if (string)
  2560.     {
  2561.       buf = (char *) alloca (3 + strlen (string));
  2562.       sprintf (buf, "\"%s\"", string);
  2563.     }
  2564.       else
  2565.     buf = "\"\"";
  2566.  
  2567.       break;
  2568.     }
  2569.  
  2570.   case T_INCLUDE_LEVEL:
  2571.     true_indepth = 0;
  2572.     for (i = indepth; i >= 0; i--)
  2573.       if (instack[i].fname != NULL)
  2574.         true_indepth++;
  2575.  
  2576.     buf = (char *) alloca (8);    /* Eigth bytes ought to be more than enough */
  2577.     sprintf (buf, "%d", true_indepth - 1);
  2578.     break;
  2579.  
  2580.   case T_VERSION:
  2581.     buf = (char *) alloca (3 + strlen (version_string));
  2582.     sprintf (buf, "\"%s\"", version_string);
  2583.     break;
  2584.  
  2585.   case T_CONST:
  2586.     buf = (char *) alloca (4 * sizeof (int));
  2587.     sprintf (buf, "%d", hp->value.ival);
  2588.     break;
  2589.  
  2590.   case T_SPECLINE:
  2591.     buf = (char *) alloca (10);
  2592.     sprintf (buf, "%d", ip->lineno);
  2593.     break;
  2594.  
  2595.   case T_DATE:
  2596.   case T_TIME:
  2597.     if (timebuf == NULL) {
  2598.       t = time (0);
  2599.       timebuf = localtime (&t);
  2600.     }
  2601.     buf = (char *) alloca (20);
  2602.     if (hp->type == T_DATE)
  2603.       sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
  2604.           timebuf->tm_mday, timebuf->tm_year + 1900);
  2605.     else
  2606.       sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
  2607.           timebuf->tm_sec);
  2608.     break;
  2609.  
  2610.   case T_SPEC_DEFINED:
  2611.     buf = " 0 ";        /* Assume symbol is not defined */
  2612.     ip = &instack[indepth];
  2613.     SKIP_WHITE_SPACE (ip->bufp);
  2614.     if (*ip->bufp == '(') {
  2615.       paren++;
  2616.       ip->bufp++;            /* Skip over the paren */
  2617.       SKIP_WHITE_SPACE (ip->bufp);
  2618.     }
  2619.  
  2620.     if (!is_idstart[*ip->bufp])
  2621.       goto oops;
  2622.     if (lookup (ip->bufp, -1, -1))
  2623.       buf = " 1 ";
  2624.     while (is_idchar[*ip->bufp])
  2625.       ++ip->bufp;
  2626.     SKIP_WHITE_SPACE (ip->bufp);
  2627.     if (paren) {
  2628.       if (*ip->bufp != ')')
  2629.     goto oops;
  2630.       ++ip->bufp;
  2631.     }
  2632.     break;
  2633.  
  2634. oops:
  2635.  
  2636.     error ("`defined' must be followed by ident or (ident)");
  2637.     break;
  2638.  
  2639.   default:
  2640.     error ("cccp error: invalid special hash type"); /* time for gdb */
  2641.     abort ();
  2642.   }
  2643.   len = strlen (buf);
  2644.   check_expand (op, len);
  2645.   bcopy (buf, op->bufp, len);
  2646.   op->bufp += len;
  2647.  
  2648.   return;
  2649. }
  2650.  
  2651.  
  2652. /* Routines to handle #directives */
  2653.  
  2654. /*
  2655.  * Process include file by reading it in and calling rescan.
  2656.  * Expects to see "fname" or <fname> on the input.
  2657.  */
  2658.  
  2659. do_include (buf, limit, op, keyword)
  2660.      U_CHAR *buf, *limit;
  2661.      FILE_BUF *op;
  2662.      struct directive *keyword;
  2663. {
  2664.   char *fname;        /* Dynamically allocated fname buffer */
  2665.   U_CHAR *fbeg, *fend;        /* Beginning and end of fname */
  2666.  
  2667.   struct file_name_list *stackp = include; /* Chain of dirs to search */
  2668.   struct file_name_list dsp[1];    /* First in chain, if #include "..." */
  2669.   int flen;
  2670.  
  2671.   int f;            /* file number */
  2672.  
  2673.   int retried = 0;        /* Have already tried macro
  2674.                    expanding the include line*/
  2675.   FILE_BUF trybuf;        /* It got expanded into here */
  2676.   int system_header_p = 0;    /* 0 for "...", 1 for <...> */
  2677.  
  2678.   f= -1;            /* JF we iz paranoid! */
  2679.  
  2680. get_filename:
  2681.  
  2682.   fbeg = buf;
  2683.   SKIP_WHITE_SPACE (fbeg);
  2684.   /* Discard trailing whitespace so we can easily see
  2685.      if we have parsed all the significant chars we were given.  */
  2686.   while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
  2687.  
  2688.   switch (*fbeg++) {
  2689.   case '\"':
  2690.     fend = fbeg;
  2691.     while (fend != limit && *fend != '\"')
  2692.       fend++;
  2693.     if (*fend == '\"' && fend + 1 == limit) {
  2694.       FILE_BUF *fp;
  2695.  
  2696.       /* We have "filename".  Figure out directory this source
  2697.      file is coming from and put it on the front of the list. */
  2698.  
  2699.       /* If -I- was specified, don't search current dir, only spec'd ones. */
  2700.       if (ignore_srcdir) break;
  2701.  
  2702.       for (fp = &instack[indepth]; fp >= instack; fp--)
  2703.     {
  2704.       int n;
  2705.       char *ep,*nam;
  2706. #if ! defined( NeXT )
  2707.           /* the next string.h file already defines rindex */
  2708.       extern char *rindex ();
  2709. #endif
  2710.  
  2711.       if ((nam = fp->fname) != NULL) {
  2712.         /* Found a named file.  Figure out dir of the file,
  2713.            and put it in front of the search list.  */
  2714.         dsp[0].next = stackp;
  2715.         stackp = dsp;
  2716. #ifndef VMS
  2717. #if defined( _MSDOS )
  2718.         ep = rindex (nam, '\\');
  2719.         if (ep == NULL) ep = rindex (nam, ':');
  2720. #else
  2721.         ep = rindex (nam, '/');
  2722. #endif
  2723. #else                /* VMS */
  2724.         ep = rindex (nam, ']');
  2725.         if (ep == NULL) ep = rindex (nam, '>');
  2726.         if (ep == NULL) ep = rindex (nam, ':');
  2727.         if (ep != NULL) ep++;
  2728. #endif                /* VMS */
  2729.         if (ep != NULL) {
  2730.           n = ep - nam;
  2731.           dsp[0].fname = (char *) alloca (n + 1);
  2732.           strncpy (dsp[0].fname, nam, n);
  2733.           dsp[0].fname[n] = '\0';
  2734.           if (n > max_include_len) max_include_len = n;
  2735.         } else {
  2736.           dsp[0].fname = 0; /* Current directory */
  2737.         }
  2738.         break;
  2739.       }
  2740.     }
  2741.       break;
  2742.     }
  2743.     goto fail;
  2744.  
  2745.   case '<':
  2746.     fend = fbeg;
  2747.     while (fend != limit && *fend != '>') fend++;
  2748.     if (*fend == '>' && fend + 1 == limit) {
  2749.       system_header_p = 1;
  2750.       /* If -I-, start with the first -I dir after the -I-.  */
  2751.       if (first_bracket_include)
  2752.     stackp = first_bracket_include;
  2753.       break;
  2754.     }
  2755.     goto fail;
  2756.  
  2757.   default:
  2758.   fail:
  2759.     if (retried) {
  2760.       error ("#include expects \"fname\" or <fname>");
  2761.       return;
  2762.     } else {
  2763.       trybuf = expand_to_temp_buffer (buf, limit, 0);
  2764.       buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
  2765.       bcopy (trybuf.buf, buf, trybuf.bufp - trybuf.buf);
  2766.       limit = buf + (trybuf.bufp - trybuf.buf);
  2767.       free (trybuf.buf);
  2768.       retried++;
  2769.       goto get_filename;
  2770.     }
  2771.   }
  2772.  
  2773.   flen = fend - fbeg;
  2774.   fname = (char *) alloca (max_include_len + flen + 2);
  2775.   /* + 2 above for slash and terminating null.  */
  2776.  
  2777.   /* If specified file name is absolute, just open it.  */
  2778.  
  2779. #if defined( _MSDOS )
  2780.   /* handle \... and x:\... */
  2781.   if ((*fbeg == '\\') ||
  2782.       (isalpha(*fbeg) && (*(fbeg + 1) == ':') && (*(fbeg + 2) == '\\'))) {
  2783. #else
  2784.   if (*fbeg == '/') {
  2785. #endif
  2786. #if defined( NeXT )
  2787.     strncpy (fname, (char *)fbeg, flen);
  2788. #else
  2789.     strncpy (fname, fbeg, flen);
  2790. #endif
  2791.     fname[flen] = 0;
  2792. #if defined( _MSDOS )
  2793.     f = open (fname, O_RDONLY | O_TEXT, 0666);
  2794. #else
  2795.     f = open (fname, O_RDONLY, 0666);
  2796. #endif
  2797.   } else {
  2798.     /* Search directory path, trying to open the file.
  2799.        Copy each filename tried into FNAME.  */
  2800.  
  2801.     for (; stackp; stackp = stackp->next) {
  2802.       if (stackp->fname) {
  2803.     strcpy (fname, stackp->fname);
  2804. #if defined( _MSDOS )
  2805.     strcat (fname, "\\");
  2806. #else
  2807.     strcat (fname, "/");
  2808. #endif
  2809.     fname[strlen (fname) + flen] = 0;
  2810.       } else {
  2811.     fname[0] = 0;
  2812.       }
  2813. #if defined( NeXT )
  2814.       strncat (fname, (char*)fbeg, flen);
  2815. #else
  2816.       strncat (fname, fbeg, flen);
  2817. #endif
  2818. #ifdef VMS
  2819.       /* Change this 1/2 Unix 1/2 VMS file specification into a
  2820.          full VMS file specification */
  2821.       if (stackp->fname && (stackp->fname[0] != 0)) {
  2822.     /* Fix up the filename */
  2823.     hack_vms_include_specification (fname);
  2824.       } else {
  2825.           /* This is a normal VMS filespec, so use it unchanged.  */
  2826.     strncpy (fname, fbeg, flen);
  2827.     fname[flen] = 0;
  2828.       }
  2829. #endif /* VMS */
  2830. #if defined( _MSDOS )
  2831.       if ((f = open (fname, O_RDONLY | O_TEXT, 0666)) >= 0)
  2832. #else
  2833.       if ((f = open (fname, O_RDONLY, 0666)) >= 0)
  2834. #endif
  2835.     break;
  2836.     }
  2837.   }
  2838.  
  2839.   if (f < 0) {
  2840. #if defined( NeXT )
  2841.     strncpy (fname, (char*)fbeg, flen);
  2842. #else
  2843.     strncpy (fname, fbeg, flen);
  2844. #endif
  2845.     fname[flen] = 0;
  2846.     error_from_errno (fname);
  2847.  
  2848.     /* For -M, add this file to the dependencies.  */
  2849.     if (print_deps > (system_header_p || (system_include_depth > 0))) {
  2850.       if (system_header_p)
  2851.     warning ("nonexistent file <%.*s> omitted from dependency output",
  2852.          fend - fbeg, fbeg);
  2853.       else
  2854.     {
  2855.       deps_output (fbeg, fend - fbeg);
  2856.       deps_output (" ", 0);
  2857.     }
  2858.     }
  2859.   } else {
  2860.  
  2861.     /* Check to see if this include file is a once-only include file.
  2862.        If so, give up.  */
  2863.  
  2864.     struct file_name_list* ptr;
  2865.  
  2866.     for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
  2867.       if (!strcmp (ptr->fname, fname)) {
  2868.     close (f);
  2869.         return;                /* This file was once'd. */
  2870.       }
  2871.     }
  2872.  
  2873.     for (ptr = all_include_files; ptr; ptr = ptr->next) {
  2874.       if (!strcmp (ptr->fname, fname))
  2875.         break;                /* This file was included before. */
  2876.     }
  2877.  
  2878.     if (ptr == 0) {
  2879.       /* This is the first time for this file.  */
  2880.       /* Add it to list of files included.  */
  2881.  
  2882.       ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
  2883.       ptr->next = all_include_files;
  2884.       all_include_files = ptr;
  2885.       ptr->fname = savestring (fname);
  2886.  
  2887.       /* For -M, add this file to the dependencies.  */
  2888.       if (print_deps > (system_header_p || (system_include_depth > 0))) {
  2889.     deps_output (fname, strlen (fname));
  2890.     deps_output (" ", 0);
  2891.       }
  2892.     }   
  2893.  
  2894.     if (system_header_p)
  2895.       system_include_depth++;
  2896.  
  2897.     /* Actually process the file.  */
  2898.     finclude (f, fname, op);
  2899.  
  2900.     if (system_header_p)
  2901.       system_include_depth--;
  2902.  
  2903.     close (f);
  2904.   }
  2905. }
  2906.  
  2907. /* Process the contents of include file FNAME, already open on descriptor F,
  2908.    with output to OP.  */
  2909.  
  2910. finclude (f, fname, op)
  2911.      int f;
  2912.      char *fname;
  2913.      FILE_BUF *op;
  2914. {
  2915.   int st_mode;
  2916.   long st_size;
  2917.   long i;
  2918.   FILE_BUF *fp;            /* For input stack frame */
  2919.   int success = 0;
  2920.  
  2921.   CHECK_DEPTH (return;);
  2922.  
  2923. #if defined( _MSDOS )
  2924.   if (file_size_and_mode (fname, &st_mode, &st_size) < 0)
  2925. #else
  2926.   if (file_size_and_mode (f, &st_mode, &st_size) < 0)
  2927. #endif
  2928.     goto nope;        /* Impossible? */
  2929.  
  2930.   fp = &instack[indepth + 1];
  2931.   bzero (fp, sizeof (FILE_BUF));
  2932.   fp->fname = fname;
  2933.   fp->length = 0;
  2934.   fp->lineno = 1;
  2935.   fp->if_stack = if_stack;
  2936.  
  2937.   if (st_mode & S_IFREG) {
  2938.     fp->buf = (U_CHAR *) alloca (st_size + 2);
  2939.     fp->bufp = fp->buf;
  2940.  
  2941.     /* Read the file contents, knowing that st_size is an upper bound
  2942.        on the number of bytes we can read.  */
  2943.     while (st_size > 0) {
  2944.       i = read (f, fp->buf + fp->length, st_size);
  2945.       if (i <= 0) {
  2946.     if (i == 0) break;
  2947.     goto nope;
  2948.       }
  2949.       fp->length += i;
  2950.       st_size -= i;
  2951.     }
  2952.   }
  2953.   else {
  2954.     /* Cannot count its file size before reading.
  2955.        First read the entire file into heap and
  2956.        copy them into buffer on stack. */
  2957.  
  2958.     U_CHAR *bufp;
  2959.     U_CHAR *basep;
  2960.     int bsize = 2000;
  2961.  
  2962.     st_size = 0;
  2963.     basep = (U_CHAR *) xmalloc (bsize + 2);
  2964.     bufp = basep;
  2965.  
  2966.     for (;;) {
  2967.       i = read (f, bufp, bsize - st_size);
  2968.       if (i < 0)
  2969.     goto nope;      /* error! */
  2970.       if (i == 0)
  2971.     break;    /* End of file */
  2972.       st_size += i;
  2973.       bufp += i;
  2974.       if (bsize == st_size) {    /* Buffer is full! */
  2975.       bsize *= 2;
  2976.       basep = (U_CHAR *) xrealloc (basep, bsize + 2);
  2977.       bufp = basep + st_size;    /* May have moved */
  2978.     }
  2979.     }
  2980.     fp->buf = (U_CHAR *) alloca (st_size + 2);
  2981.     fp->bufp = fp->buf;
  2982. #if ! defined ( _MSDOS )
  2983.     bcopy (basep, fp->buf, st_size);
  2984. #else
  2985.     bcopy (basep, fp->buf, (int) st_size);
  2986. #endif
  2987.     fp->length = st_size;
  2988.     free (basep);
  2989.   }
  2990.  
  2991.   if (!no_trigraphs)
  2992.     trigraph_pcp (fp);
  2993.  
  2994.   if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
  2995.     fp->buf[fp->length++] = '\n';
  2996.   fp->buf[fp->length] = '\0';
  2997.  
  2998.   success = 1;
  2999.   indepth++;
  3000.  
  3001.   output_line_command (fp, op, 0, enter_file);
  3002.   rescan (op, 0);
  3003.   indepth--;
  3004.   output_line_command (&instack[indepth], op, 0, leave_file);
  3005.  
  3006. nope:
  3007.  
  3008.   if (!success)
  3009.     perror_with_name (fname);
  3010.  
  3011.   close (f);
  3012. }
  3013.  
  3014. /* The arglist structure is built by do_define to tell
  3015.    collect_definition where the argument names begin.  That
  3016.    is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
  3017.    would contain pointers to the strings x, y, and z.
  3018.    Collect_definition would then build a DEFINITION node,
  3019.    with reflist nodes pointing to the places x, y, and z had
  3020.    appeared.  So the arglist is just convenience data passed
  3021.    between these two routines.  It is not kept around after
  3022.    the current #define has been processed and entered into the
  3023.    hash table. */
  3024.  
  3025. struct arglist {
  3026.   struct arglist *next;
  3027.   U_CHAR *name;
  3028.   int length;
  3029.   int argno;
  3030. };
  3031.  
  3032. /* Process a #define command.
  3033. BUF points to the contents of the #define command, as a continguous string.
  3034. LIMIT points to the first character past the end of the definition.
  3035. KEYWORD is the keyword-table entry for #define.  */
  3036.  
  3037. do_define (buf, limit, op, keyword)
  3038.      U_CHAR *buf, *limit;
  3039.      FILE_BUF *op;
  3040.      struct directive *keyword;
  3041. {
  3042.   U_CHAR *bp;            /* temp ptr into input buffer */
  3043.   U_CHAR *symname;        /* remember where symbol name starts */
  3044.   int sym_length;        /* and how long it is */
  3045.  
  3046.   DEFINITION *defn;
  3047.   int arglengths = 0;        /* Accumulate lengths of arg names
  3048.                    plus number of args.  */
  3049.   int hashcode;
  3050.  
  3051.   bp = buf;
  3052.  
  3053.   while (is_hor_space[*bp])
  3054.     bp++;
  3055.  
  3056.   symname = bp;            /* remember where it starts */
  3057.   while (is_idchar[*bp] && bp < limit) {
  3058.     bp++;
  3059.   }
  3060.   sym_length = bp - symname;
  3061.   if (sym_length == 0)
  3062.     error ("invalid macro name");
  3063.   else if (!is_idstart[*symname]) {
  3064.     U_CHAR *msg;            /* what pain... */
  3065.     msg = (U_CHAR *) alloca (sym_length + 1);
  3066.     bcopy (symname, msg, sym_length);
  3067.     msg[sym_length] = 0;
  3068.     error ("invalid macro name `%s'", msg);
  3069.   }
  3070.  
  3071.   /* lossage will occur if identifiers or control keywords are broken
  3072.      across lines using backslash.  This is not the right place to take
  3073.      care of that. */
  3074.  
  3075.   if (*bp == '(') {
  3076.     struct arglist *arg_ptrs = NULL;
  3077.     int argno = 0;
  3078.  
  3079.     bp++;            /* skip '(' */
  3080.     SKIP_WHITE_SPACE (bp);
  3081.  
  3082.     /* Loop over macro argument names.  */
  3083.     while (*bp != ')') {
  3084.       struct arglist *temp;
  3085.  
  3086.       temp = (struct arglist *) alloca (sizeof (struct arglist));
  3087.       temp->name = bp;
  3088.       temp->next = arg_ptrs;
  3089.       temp->argno = argno++;
  3090.       arg_ptrs = temp;
  3091.  
  3092.       if (!is_idstart[*bp])
  3093.     warning ("parameter name starts with a digit in #define");
  3094.  
  3095.       /* Find the end of the arg name.  */
  3096.       while (is_idchar[*bp]) {
  3097.     bp++;
  3098.       }
  3099.       temp->length = bp - temp->name;
  3100.       arglengths += temp->length + 2;
  3101.       SKIP_WHITE_SPACE (bp);
  3102.       if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
  3103.     error ("badly punctuated parameter list in #define");
  3104.     goto nope;
  3105.       }
  3106.       if (*bp == ',') {
  3107.     bp++;
  3108.     SKIP_WHITE_SPACE (bp);
  3109.       }
  3110.       if (bp >= limit) {
  3111.     error ("unterminated parameter list in #define");
  3112.     goto nope;
  3113.       }
  3114.     }
  3115.  
  3116.     ++bp;            /* skip paren */
  3117.     /* Skip exactly one space or tab if any.  */
  3118.     if (bp < limit && (*bp == ' ' || *bp == '\t')) ++bp;
  3119.     /* now everything from bp before limit is the definition. */
  3120.     defn = collect_expansion (bp, limit, argno, arg_ptrs);
  3121.  
  3122.     /* Now set defn->argnames to the result of concatenating
  3123.        the argument names in reverse order
  3124.        with comma-space between them.  */
  3125.     defn->argnames = (U_CHAR *) xmalloc (arglengths + 1);
  3126.     {
  3127.       struct arglist *temp;
  3128.       int i = 0;
  3129.       for (temp = arg_ptrs; temp; temp = temp->next) {
  3130.     bcopy (temp->name, &defn->argnames[i], temp->length);
  3131.     i += temp->length;
  3132.     if (temp->next != 0) {
  3133.       defn->argnames[i++] = ',';
  3134.       defn->argnames[i++] = ' ';
  3135.     }
  3136.       }
  3137.       defn->argnames[i] = 0;
  3138.     }
  3139.   } else {
  3140.     /* simple expansion or empty definition; gobble it */
  3141.     if (is_hor_space[*bp])
  3142.       ++bp;        /* skip exactly one blank/tab char */
  3143.     /* now everything from bp before limit is the definition. */
  3144.     defn = collect_expansion (bp, limit, -1, 0);
  3145.     defn->argnames = (U_CHAR *) "";
  3146.   }
  3147.  
  3148.   hashcode = hashf (symname, sym_length, HASHSIZE);
  3149.  
  3150.   {
  3151.     HASHNODE *hp;
  3152.     if ((hp = lookup (symname, sym_length, hashcode)) != NULL) {
  3153.       if (hp->type != T_MACRO
  3154.       || compare_defs (defn, hp->value.defn)) {
  3155.     U_CHAR *msg;            /* what pain... */
  3156.     msg = (U_CHAR *) alloca (sym_length + 20);
  3157.     bcopy (symname, msg, sym_length);
  3158.     strcpy ((char *) (msg + sym_length), " redefined");
  3159.     warning (msg);
  3160.       }
  3161.       /* Replace the old definition.  */
  3162.       hp->type = T_MACRO;
  3163.       hp->value.defn = defn;
  3164.     } else
  3165. #if ! defined( _MSDOS )
  3166.     install (symname, sym_length, T_MACRO, defn, hashcode);
  3167. #else
  3168.     install (symname, sym_length, T_MACRO, (int) defn, hashcode);
  3169. #endif
  3170.   }
  3171.  
  3172.   return 0;
  3173.  
  3174. nope:
  3175.  
  3176.   return 1;
  3177. }
  3178.  
  3179. /*
  3180.  * return zero if two DEFINITIONs are isomorphic
  3181.  */
  3182. int
  3183. compare_defs (d1, d2)
  3184.      DEFINITION *d1, *d2;
  3185. {
  3186.   register struct reflist *a1, *a2;
  3187.   register U_CHAR *p1 = d1->expansion;
  3188.   register U_CHAR *p2 = d2->expansion;
  3189.   int first = 1;
  3190.  
  3191.   if (d1->nargs != d2->nargs)
  3192.     return 1;
  3193.   if (strcmp ((char *)d1->argnames, (char *)d2->argnames))
  3194.     return 1;
  3195.   for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
  3196.        a1 = a1->next, a2 = a2->next) {
  3197. #if defined( NeXT )
  3198.     if (!((a1->nchars == a2->nchars && ! strncmp ((char*)p1, (char*)p2, a1->nchars))
  3199. #else
  3200.     if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
  3201. #endif
  3202.       || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
  3203.     || a1->argno != a2->argno
  3204.     || a1->stringify != a2->stringify
  3205.     || a1->raw_before != a2->raw_before
  3206.     || a1->raw_after != a2->raw_after)
  3207.       return 1;
  3208.     first = 0;
  3209.     p1 += a1->nchars;
  3210.     p2 += a2->nchars;
  3211.   }
  3212.   if (a1 != a2)
  3213.     return 1;
  3214.   if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
  3215.              p2, d2->length - (p2 - d2->expansion), 1))
  3216.     return 1;
  3217.   return 0;
  3218. }
  3219.  
  3220. /* Return 1 if two parts of two macro definitions are effectively different.
  3221.    One of the parts starts at BEG1 and has LEN1 chars;
  3222.    the other has LEN2 chars at BEG2.
  3223.    Any sequence of whitespace matches any other sequence of whitespace.
  3224.    FIRST means these parts are the first of a macro definition;
  3225.     so ignore leading whitespace entirely.
  3226.    LAST means these parts are the last of a macro definition;
  3227.     so ignore trailing whitespace entirely.  */
  3228.  
  3229. comp_def_part (first, beg1, len1, beg2, len2, last)
  3230.      int first;
  3231.      U_CHAR *beg1, *beg2;
  3232.      int len1, len2;
  3233.      int last;
  3234. {
  3235.   register U_CHAR *end1 = beg1 + len1;
  3236.   register U_CHAR *end2 = beg2 + len2;
  3237.   if (first) {
  3238.     while (beg1 != end1 && is_space[*beg1]) beg1++;
  3239.     while (beg2 != end2 && is_space[*beg2]) beg2++;
  3240.   }
  3241.   if (last) {
  3242.     while (beg1 != end1 && is_space[end1[-1]]) end1--;
  3243.     while (beg2 != end2 && is_space[end2[-1]]) end2--;
  3244.   }
  3245.   while (beg1 != end1 && beg2 != end2) {
  3246.     if (is_space[*beg1] && is_space[*beg2]) {
  3247.       while (beg1 != end1 && is_space[*beg1]) beg1++;
  3248.       while (beg2 != end2 && is_space[*beg2]) beg2++;
  3249.     } else if (*beg1 == *beg2) {
  3250.       beg1++; beg2++;
  3251.     } else break;
  3252.   }
  3253.   return (beg1 != end1) || (beg2 != end2);
  3254. }
  3255.  
  3256. /* Read a replacement list for a macro with parameters.
  3257.    Build the DEFINITION structure.
  3258.    Reads characters of text starting at BUF until LIMIT.
  3259.    ARGLIST specifies the formal parameters to look for
  3260.    in the text of the definition; NARGS is the number of args
  3261.    in that list, or -1 for a macro name that wants no argument list.
  3262.    MACRONAME is the macro name itself (so we can avoid recursive expansion)
  3263.    and NAMELEN is its length in characters.
  3264.    
  3265. Note that comments and backslash-newlines have already been deleted
  3266. from the argument.  */
  3267.  
  3268. /* Leading and trailing Space, Tab, etc. are converted to markers
  3269.    Newline Space, Newline Tab, etc.
  3270.    Newline Space makes a space in the final output
  3271.    but is discarded if stringified.  (Newline Tab is similar but
  3272.    makes a Tab instead.)
  3273.  
  3274.    If there is no trailing whitespace, a Newline Space is added at the end
  3275.    to prevent concatenation that would be contrary to the standard.  */
  3276.  
  3277. DEFINITION *
  3278. collect_expansion (buf, end, nargs, arglist)
  3279.      U_CHAR *buf, *end;
  3280.      int nargs;
  3281.      struct arglist *arglist;
  3282. {
  3283.   DEFINITION *defn;
  3284.   register U_CHAR *p, *limit, *lastp, *exp_p;
  3285.   struct reflist *endpat = NULL;
  3286.   /* Pointer to first nonspace after last ## seen.  */
  3287.   U_CHAR *concat = 0;
  3288.   /* Pointer to first nonspace after last single-# seen.  */
  3289.   U_CHAR *stringify = 0;
  3290.   int maxsize;
  3291.   int expected_delimiter = '\0';
  3292.  
  3293.   /* Scan thru the replacement list, ignoring comments and quoted
  3294.      strings, picking up on the macro calls.  It does a linear search
  3295.      thru the arg list on every potential symbol.  Profiling might say
  3296.      that something smarter should happen. */
  3297.  
  3298.   if (end < buf)
  3299.     abort ();
  3300.  
  3301.   /* Find the beginning of the trailing whitespace.  */
  3302.   /* Find end of leading whitespace.  */
  3303.   limit = end;
  3304.   p = buf;
  3305.   while (p < limit && is_space[limit[-1]]) limit--;
  3306.   while (p < limit && is_space[*p]) p++;
  3307.  
  3308.   /* Allocate space for the text in the macro definition.
  3309.      Leading and trailing whitespace chars need 2 bytes each.
  3310.      Each other input char may or may not need 1 byte,
  3311.      so this is an upper bound.
  3312.      The extra 2 are for invented trailing newline-marker and final null.  */
  3313.   maxsize = (sizeof (DEFINITION)
  3314.          + 2 * (end - limit) + 2 * (p - buf)
  3315.          + (limit - p) + 3);
  3316.   defn = (DEFINITION *) xcalloc (1, maxsize);
  3317.  
  3318.   defn->nargs = nargs;
  3319.   exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
  3320.   lastp = exp_p;
  3321.  
  3322.   p = buf;
  3323.  
  3324.   /* Convert leading whitespace to Newline-markers.  */
  3325.   while (p < limit && is_space[*p]) {
  3326.     *exp_p++ = '\n';
  3327.     *exp_p++ = *p++;
  3328.   }
  3329.  
  3330.   /* Process the main body of the definition.  */
  3331.   while (p < limit) {
  3332.     int skipped_arg = 0;
  3333.     register U_CHAR c = *p++;
  3334.  
  3335.     *exp_p++ = c;
  3336.  
  3337.     if (!traditional) {
  3338.       switch (c) {
  3339.       case '\'':
  3340.       case '\"':
  3341.     for (; p < limit && *p != c; p++) {
  3342.       *exp_p++ = *p;
  3343.       if (*p == '\\') {
  3344.         *exp_p++ = *++p;
  3345.       }
  3346.     }
  3347.     *exp_p++ = *p++;
  3348.     break;
  3349.  
  3350.     /* Special hack: if a \# is written in the #define
  3351.        include a # in the definition.  This is useless for C code
  3352.        but useful for preprocessing other things.  */
  3353.  
  3354.       case '\\':
  3355.     if (p < limit && *p == '#') {
  3356.       /* Pass through this # */
  3357.       exp_p--;
  3358.       *exp_p++ = *p++;
  3359.     } else if (p < limit) {
  3360.       /* Otherwise backslash goes through but makes next char ordinary.  */
  3361.       *exp_p++ = *p++;
  3362.     }
  3363.     break;
  3364.  
  3365.       case '#':
  3366.     if (p < limit && *p == '#') {
  3367.       /* ##: concatenate preceding and following tokens.  */
  3368.       /* Take out the first #, discard preceding whitespace.  */
  3369.       exp_p--;
  3370.       while (exp_p > lastp && is_hor_space[exp_p[-1]])
  3371.         --exp_p;
  3372.       /* Skip the second #.  */
  3373.       p++;
  3374.       /* Discard following whitespace.  */
  3375.       SKIP_WHITE_SPACE (p);
  3376.       concat = p;
  3377.     } else {
  3378.       /* Single #: stringify following argument ref.
  3379.          Don't leave the # in the expansion.  */
  3380.       exp_p--;
  3381.       SKIP_WHITE_SPACE (p);
  3382.       if (p == limit || ! is_idstart[*p] || nargs <= 0)
  3383.         error ("# operator should be followed by a macro argument name\n");
  3384.       else
  3385.         stringify = p;
  3386.     }
  3387.     break;
  3388.       }
  3389.     } else {
  3390.       /* In -traditional mode, recognize arguments inside strings and
  3391.      and character constants, and ignore special properties of #.
  3392.      Arguments inside strings are considered "stringified", but no
  3393.      extra quote marks are supplied.  */
  3394.       switch (c) {
  3395.       case '\'':
  3396.       case '\"':
  3397.     if (expected_delimiter != '\0') {
  3398.       if (c == expected_delimiter)
  3399.         expected_delimiter = '\0';
  3400.     } else
  3401.       expected_delimiter = c;
  3402.     break;
  3403.  
  3404.       case '\\':
  3405.     /* Backslash quotes delimiters and itself, but not macro args.  */
  3406.     if (expected_delimiter != 0 && p < limit
  3407.         && (*p == expected_delimiter || *p == '\\')) {
  3408.       *exp_p++ = *p++;
  3409.       continue;
  3410.     }
  3411.     break;
  3412.  
  3413.       case '/':
  3414.     if (expected_delimiter != '\0') /* No comments inside strings.  */
  3415.       break;
  3416.     if (*p == '*') {
  3417.       /* If we find a comment that wasn't removed by handle_directive,
  3418.          this must be -traditional.  So replace the comment with
  3419.          nothing at all.  */
  3420.       exp_p--;
  3421.       p += 1;
  3422.       while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
  3423.         p++;
  3424.       /* Mark this as a concatenation-point, as if it had been ##.  */
  3425.       concat = p;
  3426.     }
  3427.     break;
  3428.       }
  3429.     }
  3430.  
  3431.     if (is_idchar[c] && nargs > 0) {
  3432.       U_CHAR *id_beg = p - 1;
  3433.       int id_len;
  3434.  
  3435.       --exp_p;
  3436.       while (p != limit && is_idchar[*p]) p++;
  3437.       id_len = p - id_beg;
  3438.  
  3439.       if (is_idstart[c]) {
  3440.     register struct arglist *arg;
  3441.  
  3442.     for (arg = arglist; arg != NULL; arg = arg->next) {
  3443.       struct reflist *tpat;
  3444.  
  3445.       if (arg->name[0] == c
  3446.           && arg->length == id_len
  3447. #if defined( NeXT )
  3448.           && strncmp ((char*)arg->name, (char*)id_beg, id_len) == 0) {
  3449. #else
  3450.           && strncmp (arg->name, id_beg, id_len) == 0) {
  3451. #endif
  3452.         /* make a pat node for this arg and append it to the end of
  3453.            the pat list */
  3454.         tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
  3455.         tpat->next = NULL;
  3456.         tpat->raw_before = concat == id_beg;
  3457.         tpat->raw_after = 0;
  3458.         tpat->stringify = (traditional ? expected_delimiter != '\0'
  3459.                    : stringify == id_beg);
  3460.  
  3461.         if (endpat == NULL)
  3462.           defn->pattern = tpat;
  3463.         else
  3464.           endpat->next = tpat;
  3465.         endpat = tpat;
  3466.  
  3467.         tpat->argno = arg->argno;
  3468.         tpat->nchars = exp_p - lastp;
  3469.         {
  3470.           register U_CHAR *p1 = p;
  3471.           SKIP_WHITE_SPACE (p1);
  3472.           if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
  3473.         tpat->raw_after = 1;
  3474.         }
  3475.         lastp = exp_p;    /* place to start copying from next time */
  3476.         skipped_arg = 1;
  3477.         break;
  3478.       }
  3479.     }
  3480.       }
  3481.  
  3482.       /* If this was not a macro arg, copy it into the expansion.  */
  3483.       if (! skipped_arg) {
  3484.     register U_CHAR *lim1 = p;
  3485.     p = id_beg;
  3486.     while (p != lim1)
  3487.       *exp_p++ = *p++;
  3488.     if (stringify == id_beg)
  3489.       error ("# operator should be followed by a macro argument name\n");
  3490.       }
  3491.     }
  3492.   }
  3493.  
  3494.   if (limit < end) {
  3495.     /* Convert trailing whitespace to Newline-markers.  */
  3496.     while (limit < end && is_space[*limit]) {
  3497.       *exp_p++ = '\n';
  3498.       *exp_p++ = *limit++;
  3499.     }
  3500.   } else if (!traditional) {
  3501.     /* There is no trailing whitespace, so invent some.  */
  3502.     *exp_p++ = '\n';
  3503.     *exp_p++ = ' ';
  3504.   }
  3505.  
  3506.   *exp_p = '\0';
  3507.  
  3508.   defn->length = exp_p - defn->expansion;
  3509.  
  3510.   /* Crash now if we overrun the allocated size.  */
  3511.   if (defn->length + 1 > maxsize)
  3512.     abort ();
  3513.  
  3514. #if 0
  3515. /* This isn't worth the time it takes.  */
  3516.   /* give back excess storage */
  3517.   defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
  3518. #endif
  3519.  
  3520.   return defn;
  3521. }
  3522.  
  3523. /*
  3524.  * interpret #line command.  Remembers previously seen fnames
  3525.  * in its very own hash table.
  3526.  */
  3527. #define FNAME_HASHSIZE 37
  3528.  
  3529. do_line (buf, limit, op, keyword)
  3530.      U_CHAR *buf, *limit;
  3531.      FILE_BUF *op;
  3532.      struct directive *keyword;
  3533. {
  3534.   register U_CHAR *bp;
  3535.   FILE_BUF *ip = &instack[indepth];
  3536.   FILE_BUF tem;
  3537.   int new_lineno;
  3538.   enum file_change_code file_change = same_file;
  3539.  
  3540.   /* Expand any macros.  */
  3541.   tem = expand_to_temp_buffer (buf, limit, 0);
  3542.  
  3543.   /* Point to macroexpanded line, which is null-terminated now.  */
  3544.   bp = tem.buf;
  3545.   SKIP_WHITE_SPACE (bp);
  3546.  
  3547.   if (!isdigit (*bp)) {
  3548.     error ("invalid format #line command");
  3549.     return;
  3550.   }
  3551.  
  3552.   /* The Newline at the end of this line remains to be processed.
  3553.      To put the next line at the specified line number,
  3554.      we must store a line number now that is one less.  */
  3555.   new_lineno = atoi (bp) - 1;
  3556.  
  3557.   /* skip over the line number.  */
  3558.   while (isdigit (*bp))
  3559.     bp++;
  3560.   if (*bp && !is_space[*bp]) {
  3561.     error ("invalid format #line command");
  3562.     return;
  3563.   }
  3564.     
  3565.   SKIP_WHITE_SPACE (bp);
  3566.  
  3567.   if (*bp == '\"') {
  3568.     static HASHNODE *fname_table[FNAME_HASHSIZE];
  3569.     HASHNODE *hp, **hash_bucket;
  3570.     U_CHAR *fname;
  3571.     int fname_length;
  3572.  
  3573.     fname = ++bp;
  3574.  
  3575.     while (*bp && *bp != '\"')
  3576.       bp++;
  3577.     if (*bp != '\"') {
  3578.       error ("invalid format #line command");
  3579.       return;
  3580.     }
  3581.  
  3582.     fname_length = bp - fname;
  3583.  
  3584.     bp++;
  3585.     SKIP_WHITE_SPACE (bp);
  3586.     if (*bp) {
  3587.       if (*bp == '1')
  3588.     file_change = enter_file;
  3589.       else if (*bp == '2')
  3590.     file_change = leave_file;
  3591.       else {
  3592.     error ("invalid format #line command");
  3593.     return;
  3594.       }
  3595.  
  3596.       bp++;
  3597.       SKIP_WHITE_SPACE (bp);
  3598.       if (*bp) {
  3599.     error ("invalid format #line command");
  3600.     return;
  3601.       }
  3602.     }
  3603.  
  3604.     hash_bucket =
  3605.       &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
  3606.     for (hp = *hash_bucket; hp != NULL; hp = hp->next)
  3607.       if (hp->length == fname_length &&
  3608. #if defined( NeXT )
  3609.       strncmp (hp->value.cpval, (char*)fname, fname_length) == 0) {
  3610. #else
  3611.       strncmp (hp->value.cpval, fname, fname_length) == 0) {
  3612. #endif
  3613.     ip->fname = hp->value.cpval;
  3614.     break;
  3615.       }
  3616.     if (hp == 0) {
  3617.       /* Didn't find it; cons up a new one.  */
  3618.       hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
  3619.       hp->next = *hash_bucket;
  3620.       *hash_bucket = hp;
  3621.  
  3622.       hp->length = fname_length;
  3623.       ip->fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
  3624.       bcopy (fname, hp->value.cpval, fname_length);
  3625.     }
  3626.   } else if (*bp) {
  3627.     error ("invalid format #line command");
  3628.     return;
  3629.   }
  3630.  
  3631.   ip->lineno = new_lineno;
  3632.   output_line_command (ip, op, 0, file_change);
  3633.   check_expand (op, ip->length - (ip->bufp - ip->buf));
  3634. }
  3635.  
  3636. /*
  3637.  * remove all definitions of symbol from symbol table.
  3638.  * according to un*x /lib/cpp, it is not an error to undef
  3639.  * something that has no definitions, so it isn't one here either.
  3640.  */
  3641. do_undef (buf, limit, op, keyword)
  3642.      U_CHAR *buf, *limit;
  3643.      FILE_BUF *op;
  3644.      struct directive *keyword;
  3645. {
  3646.   HASHNODE *hp;
  3647.  
  3648.   SKIP_WHITE_SPACE (buf);
  3649.  
  3650.   while ((hp = lookup (buf, -1, -1)) != NULL) {
  3651.     if (hp->type != T_MACRO)
  3652.       error ("undefining `%s'", hp->name);
  3653.     delete_macro (hp);
  3654.   }
  3655. }
  3656.  
  3657. /*
  3658.  * Report a fatal error detected by the program we are processing.
  3659.  * Use the text of the line in the error message, then terminate.
  3660.  * (We use error() because it prints the filename & line#.)
  3661.  */
  3662. do_error (buf, limit, op, keyword)
  3663.      U_CHAR *buf, *limit;
  3664.      FILE_BUF *op;
  3665.      struct directive *keyword;
  3666. {
  3667.   int length = limit - buf;
  3668.   char *copy = (char *) xmalloc (length + 1);
  3669.   bcopy (buf, copy, length);
  3670.   copy[length] = 0;
  3671.   SKIP_WHITE_SPACE (copy);
  3672.   error ("#error %s", copy);
  3673.   exit (FATAL_EXIT_CODE);
  3674. }
  3675.  
  3676. /* Remember the name of the current file being read from so that we can
  3677.    avoid ever including it again.  */
  3678.  
  3679. do_once ()
  3680. {
  3681.   int i;
  3682.   FILE_BUF *ip = NULL;
  3683.  
  3684.   for (i = indepth; i >= 0; i--)
  3685.     if (instack[i].fname != NULL) {
  3686.       ip = &instack[i];
  3687.       break;
  3688.     }
  3689.  
  3690.   if (ip != NULL)
  3691.     {
  3692.       struct file_name_list *new;
  3693.  
  3694.       new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
  3695.       new->next = dont_repeat_files;
  3696.       dont_repeat_files = new;
  3697.       new->fname = savestring (ip->fname);
  3698.     }
  3699. }
  3700.  
  3701. /* #pragma and its argument line have already been copied to the output file.
  3702.    Here just check for recognized pragmas.  */
  3703.  
  3704. do_pragma (buf, limit)
  3705.      U_CHAR *buf, *limit;
  3706. {
  3707.   while (*buf == ' ' || *buf == '\t')
  3708.     buf++;
  3709. #if defined( NeXT )
  3710.   if (!strncmp ((char*)buf, "once", 4))
  3711. #else
  3712.   if (!strncmp (buf, "once", 4))
  3713. #endif
  3714.     do_once ();
  3715. }
  3716.  
  3717. #if 0
  3718. /* This was a fun hack, but #pragma seems to start to be useful.
  3719.    By failing to recognize it, we pass it through unchanged to cc1.  */
  3720.  
  3721. /*
  3722.  * the behavior of the #pragma directive is implementation defined.
  3723.  * this implementation defines it as follows.
  3724.  */
  3725. do_pragma ()
  3726. {
  3727.   close (0);
  3728.   if (open ("/dev/tty", O_RDONLY, 0666) != 0)
  3729.     goto nope;
  3730.   close (1);
  3731.   if (open ("/dev/tty", O_WRONLY, 0666) != 1)
  3732.     goto nope;
  3733.   execl ("/usr/games/hack", "#pragma", 0);
  3734.   execl ("/usr/games/rogue", "#pragma", 0);
  3735.   execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
  3736.   execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
  3737. nope:
  3738.   fatal ("You are in a maze of twisty compiler features, all different");
  3739. }
  3740. #endif
  3741.  
  3742. /* Just ignore #sccs, on systems where we define it at all.  */
  3743. do_sccs ()
  3744. {
  3745.   if (pedantic)
  3746.     error ("ANSI C does not allow #sccs");
  3747. }
  3748.  
  3749. /*
  3750.  * handle #if command by
  3751.  *   1) inserting special `defined' keyword into the hash table
  3752.  *    that gets turned into 0 or 1 by special_symbol (thus,
  3753.  *    if the luser has a symbol called `defined' already, it won't
  3754.  *      work inside the #if command)
  3755.  *   2) rescan the input into a temporary output buffer
  3756.  *   3) pass the output buffer to the yacc parser and collect a value
  3757.  *   4) clean up the mess left from steps 1 and 2.
  3758.  *   5) call conditional_skip to skip til the next #endif (etc.),
  3759.  *      or not, depending on the value from step 3.
  3760.  */
  3761.  
  3762. do_if (buf, limit, op, keyword)
  3763.      U_CHAR *buf, *limit;
  3764.      FILE_BUF *op;
  3765.      struct directive *keyword;
  3766. {
  3767.   int value;
  3768.   FILE_BUF *ip = &instack[indepth];
  3769.  
  3770.   value = eval_if_expression (buf, limit - buf);
  3771.   conditional_skip (ip, value == 0, T_IF);
  3772. }
  3773.  
  3774. /*
  3775.  * handle a #elif directive by not changing  if_stack  either.
  3776.  * see the comment above do_else.
  3777.  */
  3778.  
  3779. do_elif (buf, limit, op, keyword)
  3780.      U_CHAR *buf, *limit;
  3781.      FILE_BUF *op;
  3782.      struct directive *keyword;
  3783. {
  3784.   int value;
  3785.   FILE_BUF *ip = &instack[indepth];
  3786.  
  3787.   if (if_stack == instack[indepth].if_stack) {
  3788.     error ("#elif not within a conditional");
  3789.     return;
  3790.   } else {
  3791.     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
  3792.       error ("#elif after #else");
  3793.       fprintf (stderr, " (matches line %d", if_stack->lineno);
  3794.       if (if_stack->fname != NULL && ip->fname != NULL &&
  3795.       strcmp (if_stack->fname, ip->fname) != 0)
  3796.     fprintf (stderr, ", file %s", if_stack->fname);
  3797.       fprintf (stderr, ")\n");
  3798.     }
  3799.     if_stack->type = T_ELIF;
  3800.   }
  3801.  
  3802.   if (if_stack->if_succeeded)
  3803.     skip_if_group (ip, 0);
  3804.   else {
  3805.     value = eval_if_expression (buf, limit - buf);
  3806.     if (value == 0)
  3807.       skip_if_group (ip, 0);
  3808.     else {
  3809.       ++if_stack->if_succeeded;    /* continue processing input */
  3810.       output_line_command (ip, op, 1, same_file);
  3811.     }
  3812.   }
  3813. }
  3814.  
  3815. /*
  3816.  * evaluate a #if expression in BUF, of length LENGTH,
  3817.  * then parse the result as a C expression and return the value as an int.
  3818.  */
  3819. int
  3820. eval_if_expression (buf, length)
  3821.      U_CHAR *buf;
  3822.      int length;
  3823. {
  3824.   FILE_BUF temp_obuf;
  3825.   HASHNODE *save_defined;
  3826.   int value;
  3827.  
  3828.   save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, -1);
  3829.   temp_obuf = expand_to_temp_buffer (buf, buf + length, 0);
  3830.   delete_macro (save_defined);    /* clean up special symbol */
  3831.  
  3832.   value = parse_c_expression (temp_obuf.buf);
  3833.  
  3834.   free (temp_obuf.buf);
  3835.  
  3836.   return value;
  3837. }
  3838.  
  3839. /*
  3840.  * routine to handle ifdef/ifndef.  Try to look up the symbol,
  3841.  * then do or don't skip to the #endif/#else/#elif depending
  3842.  * on what directive is actually being processed.
  3843.  */
  3844. do_xifdef (buf, limit, op, keyword)
  3845.      U_CHAR *buf, *limit;
  3846.      FILE_BUF *op;
  3847.      struct directive *keyword;
  3848. {
  3849.   int skip;
  3850.   FILE_BUF *ip = &instack[indepth];
  3851.   U_CHAR *end; 
  3852.  
  3853.   /* Discard leading and trailing whitespace.  */
  3854.   SKIP_WHITE_SPACE (buf);
  3855.   while (limit != buf && is_hor_space[limit[-1]]) limit--;
  3856.  
  3857.   /* Find the end of the identifier at the beginning.  */
  3858.   for (end = buf; is_idchar[*end]; end++);
  3859.  
  3860.   if (end == buf) {
  3861.     skip = (keyword->type == T_IFDEF);
  3862.     if (! traditional)
  3863.       warning (end == limit ? "#%s with no argument"
  3864.            : "#%s argument starts with punctuation",
  3865.            keyword->name);
  3866.   } else {
  3867.     if (pedantic && buf[0] >= '0' && buf[0] <= '9')
  3868.       warning ("#%s argument starts with a digit", keyword->name);
  3869.     else if (end != limit && !traditional)
  3870.       warning ("garbage at end of #%s argument", keyword->name);
  3871.  
  3872.     skip = (lookup (buf, end-buf, -1) == NULL) ^ (keyword->type == T_IFNDEF);
  3873.   }
  3874.  
  3875.   conditional_skip (ip, skip, T_IF);
  3876. }
  3877.  
  3878. /*
  3879.  * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
  3880.  */
  3881. void
  3882. conditional_skip (ip, skip, type)
  3883.      FILE_BUF *ip;
  3884.      int skip;
  3885.      enum node_type type;
  3886. {
  3887.   IF_STACK_FRAME *temp;
  3888.  
  3889.   temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
  3890.   temp->fname = ip->fname;
  3891.   temp->lineno = ip->lineno;
  3892.   temp->next = if_stack;
  3893.   if_stack = temp;
  3894.  
  3895.   if_stack->type = type;
  3896.  
  3897.   if (skip != 0) {
  3898.     skip_if_group (ip, 0);
  3899.     return;
  3900.   } else {
  3901.     ++if_stack->if_succeeded;
  3902.     output_line_command (ip, &outbuf, 1, same_file);
  3903.   }
  3904. }
  3905.  
  3906. /*
  3907.  * skip to #endif, #else, or #elif.  adjust line numbers, etc.
  3908.  * leaves input ptr at the sharp sign found.
  3909.  * If ANY is nonzero, return at next directive of any sort.
  3910.  */
  3911. void
  3912. skip_if_group (ip, any)
  3913.      FILE_BUF *ip;
  3914.      int any;
  3915. {
  3916.   register U_CHAR *bp = ip->bufp, *cp;
  3917.   register U_CHAR *endb = ip->buf + ip->length;
  3918.   struct directive *kt;
  3919.   IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
  3920.   U_CHAR *beg_of_line = bp;
  3921.  
  3922.   while (bp < endb) {
  3923.     switch (*bp++) {
  3924.     case '/':            /* possible comment */
  3925.       if (*bp == '\\' && bp[1] == '\n')
  3926.     newline_fix (bp);
  3927.       if (*bp == '*'
  3928.       || (cplusplus && *bp == '/')) {
  3929.     ip->bufp = ++bp;
  3930.     bp = skip_to_end_of_comment (ip, &ip->lineno);
  3931.       }
  3932.       break;
  3933.     case '\"':
  3934.     case '\'':
  3935.       bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno, 0, 0);
  3936.       break;
  3937.     case '\\':
  3938.       /* Char after backslash loses its special meaning.  */
  3939.       if (bp < endb) {
  3940.     if (*bp == '\n')
  3941.       ++ip->lineno;        /* But do update the line-count.  */
  3942.     bp++;
  3943.       }
  3944.       break;
  3945.     case '\n':
  3946.       ++ip->lineno;
  3947.       beg_of_line = bp;
  3948.       break;
  3949.     case '#':
  3950.       ip->bufp = bp - 1;
  3951.  
  3952.       /* # keyword: a # must be first nonblank char on the line */
  3953.       if (beg_of_line == 0)
  3954.     break;
  3955.       /* Scan from start of line, skipping whitespace, comments
  3956.      and backslash-newlines, and see if we reach this #.
  3957.      If not, this # is not special.  */
  3958.       bp = beg_of_line;
  3959.       while (1) {
  3960.     if (is_hor_space[*bp])
  3961.       bp++;
  3962.     else if (*bp == '\\' && bp[1] == '\n')
  3963.       bp += 2;
  3964.     else if (*bp == '/' && bp[1] == '*') {
  3965.       bp += 2;
  3966.       while (!(*bp == '*' && bp[1] == '/'))
  3967.         bp++;
  3968.       bp += 2;
  3969.     }
  3970.     else if (cplusplus && *bp == '/' && bp[1] == '/') {
  3971.       bp += 2;
  3972.       while (*bp++ != '\n') ;
  3973.         }
  3974.     else break;
  3975.       }
  3976.       if (bp != ip->bufp) {
  3977.     bp = ip->bufp + 1;    /* Reset bp to after the #.  */
  3978.     break;
  3979.       }
  3980.  
  3981.       bp = ip->bufp + 1;        /* point at '#' */
  3982.  
  3983.       /* Skip whitespace and \-newline.  */
  3984.       while (1) {
  3985.     if (is_hor_space[*bp])
  3986.       bp++;
  3987.     else if (*bp == '\\' && bp[1] == '\n')
  3988.       bp += 2;
  3989.     else break;
  3990.       }
  3991.  
  3992.       cp = bp;
  3993.  
  3994.       /* Now find end of directive name.
  3995.      If we encounter a backslash-newline, exchange it with any following
  3996.      symbol-constituents so that we end up with a contiguous name.  */
  3997.  
  3998.       while (1) {
  3999.     if (is_idchar[*bp])
  4000.       bp++;
  4001.     else {
  4002.       if (*bp == '\\' && bp[1] == '\n')
  4003.         name_newline_fix (bp);
  4004.       if (is_idchar[*bp])
  4005.         bp++;
  4006.       else break;
  4007.     }
  4008.       }
  4009.  
  4010.       for (kt = directive_table; kt->length >= 0; kt++) {
  4011.     IF_STACK_FRAME *temp;
  4012. #if defined( NeXT )
  4013.     if (strncmp ((char*)cp, (char*)kt->name, kt->length) == 0
  4014. #else
  4015.     if (strncmp (cp, kt->name, kt->length) == 0
  4016. #endif
  4017.         && !is_idchar[cp[kt->length]]) {
  4018.  
  4019.       /* If we are asked to return on next directive,
  4020.          do so now.  */
  4021.       if (any)
  4022.         return;
  4023.  
  4024.       switch (kt->type) {
  4025.       case T_IF:
  4026.       case T_IFDEF:
  4027.       case T_IFNDEF:
  4028.         temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
  4029.         temp->next = if_stack;
  4030.         if_stack = temp;
  4031.         temp->lineno = ip->lineno;
  4032.         temp->fname = ip->fname;
  4033.         temp->type = kt->type;
  4034.         break;
  4035.       case T_ELSE:
  4036.       case T_ENDIF:
  4037.         if (pedantic && if_stack != save_if_stack)
  4038.           validate_else (bp);
  4039.       case T_ELIF:
  4040.         if (if_stack == instack[indepth].if_stack) {
  4041.           error ("#%s not within a conditional", kt->name);
  4042.           break;
  4043.         }
  4044.         else if (if_stack == save_if_stack)
  4045.           return;        /* found what we came for */
  4046.  
  4047.         if (kt->type != T_ENDIF) {
  4048.           if (if_stack->type == T_ELSE)
  4049.         error ("#else or #elif after #else");
  4050.           if_stack->type = kt->type;
  4051.           break;
  4052.         }
  4053.  
  4054.         temp = if_stack;
  4055.         if_stack = if_stack->next;
  4056.         free (temp);
  4057.         break;
  4058.       }
  4059.       break;
  4060.     }
  4061.       }
  4062.     }
  4063.   }
  4064.   ip->bufp = bp;
  4065.   /* after this returns, rescan will exit because ip->bufp
  4066.      now points to the end of the buffer.
  4067.      rescan is responsible for the error message also.  */
  4068. }
  4069.  
  4070. /*
  4071.  * handle a #else directive.  Do this by just continuing processing
  4072.  * without changing  if_stack ;  this is so that the error message
  4073.  * for missing #endif's etc. will point to the original #if.  It
  4074.  * is possible that something different would be better.
  4075.  */
  4076. do_else (buf, limit, op, keyword)
  4077.      U_CHAR *buf, *limit;
  4078.      FILE_BUF *op;
  4079.      struct directive *keyword;
  4080. {
  4081.   FILE_BUF *ip = &instack[indepth];
  4082.  
  4083.   if (pedantic) {
  4084.     SKIP_WHITE_SPACE (buf);
  4085.     if (buf != limit)
  4086.       warning ("text following #else violates ANSI standard");
  4087.   }
  4088.  
  4089.   if (if_stack == instack[indepth].if_stack) {
  4090.     error ("#else not within a conditional");
  4091.     return;
  4092.   } else {
  4093.     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
  4094.       error ("#else after #else");
  4095.       fprintf (stderr, " (matches line %d", if_stack->lineno);
  4096.       if (strcmp (if_stack->fname, ip->fname) != 0)
  4097.     fprintf (stderr, ", file %s", if_stack->fname);
  4098.       fprintf (stderr, ")\n");
  4099.     }
  4100.     if_stack->type = T_ELSE;
  4101.   }
  4102.  
  4103.   if (if_stack->if_succeeded)
  4104.     skip_if_group (ip, 0);
  4105.   else {
  4106.     ++if_stack->if_succeeded;    /* continue processing input */
  4107.     output_line_command (ip, op, 1, same_file);
  4108.   }
  4109. }
  4110.  
  4111. /*
  4112.  * unstack after #endif command
  4113.  */
  4114. do_endif (buf, limit, op, keyword)
  4115.      U_CHAR *buf, *limit;
  4116.      FILE_BUF *op;
  4117.      struct directive *keyword;
  4118. {
  4119.   if (pedantic) {
  4120.     SKIP_WHITE_SPACE (buf);
  4121.     if (buf != limit)
  4122.       warning ("text following #endif violates ANSI standard");
  4123.   }
  4124.  
  4125.   if (if_stack == instack[indepth].if_stack)
  4126.     error ("unbalanced #endif");
  4127.   else {
  4128.     IF_STACK_FRAME *temp = if_stack;
  4129.     if_stack = if_stack->next;
  4130.     free (temp);
  4131.     output_line_command (&instack[indepth], op, 1, same_file);
  4132.   }
  4133. }
  4134.  
  4135. /* When an #else or #endif is found while skipping failed conditional,
  4136.    if -pedantic was specified, this is called to warn about text after
  4137.    the command name.  P points to the first char after the command name.  */
  4138.  
  4139. validate_else (p)
  4140.      register U_CHAR *p;
  4141. {
  4142.   /* Advance P over whitespace and comments.  */
  4143.   while (1) {
  4144.     if (*p == '\\' && p[1] == '\n')
  4145.       p += 2;
  4146.     if (is_hor_space[*p])
  4147.       p++;
  4148.     else if (*p == '/') {
  4149.       if (p[1] == '\\' && p[2] == '\n')
  4150.     newline_fix (p + 1);
  4151.       if (p[1] == '*') {
  4152.     p += 2;
  4153.     /* Don't bother warning about unterminated comments
  4154.        since that will happen later.  Just be sure to exit.  */
  4155.     while (*p) {
  4156.       if (p[1] == '\\' && p[2] == '\n')
  4157.         newline_fix (p + 1);
  4158.       if (*p == '*' && p[1] == '/') {
  4159.         p += 2;
  4160.         break;
  4161.       }
  4162.       p++;
  4163.     }
  4164.       }
  4165.       else if (cplusplus && p[1] == '/') {
  4166.     p += 2;
  4167.     while (*p && *p++ != '\n') ;
  4168.       }
  4169.     } else break;
  4170.   }
  4171.   if (*p && *p != '\n')
  4172.     warning ("text following #else or #endif violates ANSI standard");
  4173. }
  4174.  
  4175. /*
  4176.  * Skip a comment, assuming the input ptr immediately follows the
  4177.  * initial slash-star.  Bump line counter as necessary.
  4178.  * (The canonical line counter is &ip->lineno).
  4179.  * Don't use this routine (or the next one) if bumping the line
  4180.  * counter is not sufficient to deal with newlines in the string.
  4181.  */
  4182. U_CHAR *
  4183. skip_to_end_of_comment (ip, line_counter)
  4184.      register FILE_BUF *ip;
  4185.      int *line_counter;        /* place to remember newlines, or NULL */
  4186. {
  4187.   register U_CHAR *limit = ip->buf + ip->length;
  4188.   register U_CHAR *bp = ip->bufp;
  4189.   FILE_BUF *op = &outbuf;    /* JF */
  4190.   int output = put_out_comments && !line_counter;
  4191.  
  4192.     /* JF this line_counter stuff is a crock to make sure the
  4193.        comment is only put out once, no matter how many times
  4194.        the comment is skipped.  It almost works */
  4195.   if (output) {
  4196.     *op->bufp++ = '/';
  4197.     *op->bufp++ = '*';
  4198.   }
  4199.   if (cplusplus && bp[-1] == '/') {
  4200.     if (output) {
  4201.       while (bp < limit)
  4202.     if ((*op->bufp++ = *bp++) == '\n') {
  4203.       bp--;
  4204.       break;
  4205.     }
  4206.       op->bufp[-1] = '*';
  4207.       *op->bufp++ = '/';
  4208.       *op->bufp++ = '\n';
  4209.     } else {
  4210.       while (bp < limit) {
  4211.     if (*bp++ == '\n') {
  4212.       bp--;
  4213.       break;
  4214.     }
  4215.       }
  4216.     }
  4217.     ip->bufp = bp;
  4218.     return bp;
  4219.   }
  4220.   while (bp < limit) {
  4221.     if (output)
  4222.       *op->bufp++ = *bp;
  4223.     switch (*bp++) {
  4224.     case '\n':
  4225.       if (line_counter != NULL)
  4226.     ++*line_counter;
  4227.       if (output)
  4228.     ++op->lineno;
  4229.       break;
  4230.     case '*':
  4231.       if (*bp == '\\' && bp[1] == '\n')
  4232.     newline_fix (bp);
  4233.       if (*bp == '/') {
  4234.         if (output)
  4235.       *op->bufp++ = '/';
  4236.     ip->bufp = ++bp;
  4237.     return bp;
  4238.       }
  4239.       break;
  4240.     }
  4241.   }
  4242.   ip->bufp = bp;
  4243.   return bp;
  4244. }
  4245.  
  4246. /*
  4247.  * Skip over a quoted string.  BP points to the opening quote.
  4248.  * Returns a pointer after the closing quote.  Don't go past LIMIT.
  4249.  * START_LINE is the line number of the starting point (but it need
  4250.  * not be valid if the starting point is inside a macro expansion).
  4251.  *
  4252.  * The input stack state is not changed.
  4253.  *
  4254.  * If COUNT_NEWLINES is nonzero, it points to an int to increment
  4255.  * for each newline passed.
  4256.  *
  4257.  * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
  4258.  * if we pass a backslash-newline.
  4259.  *
  4260.  * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
  4261.  */
  4262. U_CHAR *
  4263. skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
  4264.      register U_CHAR *bp;
  4265.      register U_CHAR *limit;
  4266.      int start_line;
  4267.      int *count_newlines;
  4268.      int *backslash_newlines_p;
  4269.      int *eofp;
  4270. {
  4271.   register U_CHAR c, match;
  4272.  
  4273.   match = *bp++;
  4274.   while (1) {
  4275.     if (bp >= limit) {
  4276.       error_with_line (line_for_error (start_line),
  4277.                "unterminated string or character constant");
  4278.       if (eofp)
  4279.     *eofp = 1;
  4280.       break;
  4281.     }
  4282.     c = *bp++;
  4283.     if (c == '\\') {
  4284.       while (*bp == '\\' && bp[1] == '\n') {
  4285.     if (backslash_newlines_p)
  4286.       *backslash_newlines_p = 1;
  4287.     if (count_newlines)
  4288.       ++*count_newlines;
  4289.     bp += 2;
  4290.       }
  4291.       if (*bp == '\n' && count_newlines) {
  4292.     if (backslash_newlines_p)
  4293.       *backslash_newlines_p = 1;
  4294.     ++*count_newlines;
  4295.       }
  4296.       bp++;
  4297.     } else if (c == '\n') {
  4298.       if (traditional) {
  4299.      /* Unterminated strings and character constants are 'legal'.  */
  4300.      bp--;    /* Don't consume the newline. */
  4301.      if (eofp)
  4302.        *eofp = 1;
  4303.      break;
  4304.       }
  4305.       if (match == '\'') {
  4306.     error_with_line (line_for_error (start_line),
  4307.              "unterminated character constant");
  4308.     bp--;
  4309.     if (eofp)
  4310.       *eofp = 1;
  4311.     break;
  4312.       }
  4313.       if (traditional) {    /* Unterminated strings are 'legal'.  */
  4314.     if (eofp)
  4315.       *eofp = 1;
  4316.     break;
  4317.       }
  4318.       /* If not traditional, then allow newlines inside strings.  */
  4319.       if (count_newlines)
  4320.     ++*count_newlines;
  4321.     } else if (c == match)
  4322.       break;
  4323.   }
  4324.   return bp;
  4325. }
  4326.  
  4327. /*
  4328.  * write out a #line command, for instance, after an #include file.
  4329.  * If CONDITIONAL is nonzero, we can omit the #line if it would
  4330.  * appear to be a no-op, and we can output a few newlines instead
  4331.  * if we want to increase the line number by a small amount.
  4332.  * FILE_CHANGE says whether we are entering a file, leaving, or neither.
  4333.  */
  4334.  
  4335. void
  4336. output_line_command (ip, op, conditional, file_change)
  4337.      FILE_BUF *ip, *op;
  4338.      int conditional;
  4339.      enum file_change_code file_change;
  4340. {
  4341.   int len;
  4342.   char line_cmd_buf[500];
  4343.  
  4344.   if (no_line_commands
  4345.       || ip->fname == NULL
  4346.       || no_output) {
  4347.     op->lineno = ip->lineno;
  4348.     return;
  4349.   }
  4350.  
  4351.   if (conditional) {
  4352.     if (ip->lineno == op->lineno)
  4353.       return;
  4354.  
  4355.     /* If the inherited line number is a little too small,
  4356.        output some newlines instead of a #line command.  */
  4357.     if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
  4358.       check_expand (op, 10);
  4359.       while (ip->lineno > op->lineno) {
  4360.     *op->bufp++ = '\n';
  4361.     op->lineno++;
  4362.       }
  4363.       return;
  4364.     }
  4365.   }
  4366.  
  4367. #ifdef OUTPUT_LINE_COMMANDS
  4368.   sprintf (line_cmd_buf, "#line %d \"%s\"", ip->lineno, ip->fname);
  4369. #else
  4370. #if defined ( _MSDOS )
  4371. {
  4372.     int how_many_slashes = 0;
  4373.     char *safe_name, *look = ip->fname, *src = ip->fname;
  4374.     
  4375.     do
  4376.     {
  4377.     if ( '\\' == ( *look ))
  4378.     {
  4379.         ++ how_many_slashes;
  4380.     }
  4381.     }
  4382.     while ( '\0' != ( *( look ++ )));
  4383.  
  4384.     look = ( safe_name = xmalloc ( how_many_slashes + ( look - src )));
  4385.  
  4386.     do
  4387.     {
  4388.     *look = *src;
  4389.     
  4390.     if ( '\\' == ( *( look ++ )))
  4391.     {
  4392.         *( look ++ ) = '\\';
  4393.     }
  4394.     }
  4395.     while ( '\0' != ( *( src ++ )));
  4396.     
  4397.     sprintf (line_cmd_buf, "# %d \"%s\"", ip->lineno, safe_name );
  4398.     free ( safe_name );
  4399. }
  4400. #else
  4401.   sprintf (line_cmd_buf, "# %d \"%s\"", ip->lineno, ip->fname);
  4402. #endif
  4403. #endif
  4404.  
  4405. #if ! defined( OUTPUT_LINE_COMMANDS )
  4406.   if (file_change != same_file)
  4407.     strcat (line_cmd_buf, file_change == enter_file ? " 1" : " 2");
  4408. #endif
  4409.   len = strlen (line_cmd_buf);
  4410.   line_cmd_buf[len++] = '\n';
  4411.   check_expand (op, len + 1);
  4412.   if (op->bufp > op->buf && op->bufp[-1] != '\n')
  4413.     *op->bufp++ = '\n';
  4414.   bcopy (line_cmd_buf, op->bufp, len);
  4415.   op->bufp += len;
  4416.   op->lineno = ip->lineno;
  4417. }
  4418.  
  4419. /* This structure represents one parsed argument in a macro call.
  4420.    `raw' points to the argument text as written (`raw_length' is its length).
  4421.    `expanded' points to the argument's macro-expansion
  4422.    (its length is `expand_length').
  4423.    `stringified_length' is the length the argument would have
  4424.    if stringified.
  4425.    `free1' and `free2', if nonzero, point to blocks to be freed
  4426.    when the macro argument data is no longer needed.  */
  4427.  
  4428. struct argdata {
  4429.   U_CHAR *raw, *expanded;
  4430.   int raw_length, expand_length;
  4431.   int stringified_length;
  4432.   U_CHAR *free1, *free2;
  4433.   char newlines;
  4434.   char comments;
  4435. };
  4436.  
  4437. /* Expand a macro call.
  4438.    HP points to the symbol that is the macro being called.
  4439.    Put the result of expansion onto the input stack
  4440.    so that subsequent input by our caller will use it.
  4441.  
  4442.    If macro wants arguments, caller has already verified that
  4443.    an argument list follows; arguments come from the input stack.  */
  4444.  
  4445. void
  4446. macroexpand (hp, op)
  4447.      HASHNODE *hp;
  4448.      FILE_BUF *op;
  4449. {
  4450.   int nargs;
  4451.   DEFINITION *defn = hp->value.defn;
  4452.   register U_CHAR *xbuf;
  4453.   int xbuf_len;
  4454.   int start_line = instack[indepth].lineno;
  4455.  
  4456.   CHECK_DEPTH (return;);
  4457.  
  4458.   /* it might not actually be a macro.  */
  4459.   if (hp->type != T_MACRO) {
  4460.     special_symbol (hp, op);
  4461.     return;
  4462.   }
  4463.  
  4464.   nargs = defn->nargs;
  4465.  
  4466.   if (nargs >= 0) {
  4467.     register int i;
  4468.     struct argdata *args;
  4469.     char *parse_error = 0;
  4470.  
  4471.     args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
  4472.  
  4473.     for (i = 0; i < nargs; i++) {
  4474.       args[i].raw = args[i].expanded = (U_CHAR *) "";
  4475.       args[i].raw_length = args[i].expand_length
  4476.     = args[i].stringified_length = 0;
  4477.       args[i].free1 = args[i].free2 = 0;
  4478.     }
  4479.  
  4480.     /* Parse all the macro args that are supplied.  I counts them.
  4481.        The first NARGS args are stored in ARGS.
  4482.        The rest are discarded.  */
  4483.     i = 0;
  4484.     do {
  4485.       /* Discard the open-parenthesis or comma before the next arg.  */
  4486.       ++instack[indepth].bufp;
  4487.       parse_error
  4488.     = macarg ((i < nargs || (nargs == 0 && i == 0)) ? &args[i] : 0);
  4489.       if (parse_error)
  4490.     {
  4491.       error_with_line (line_for_error (start_line), parse_error);
  4492.       break;
  4493.     }
  4494.       i++;
  4495.     } while (*instack[indepth].bufp != ')');
  4496.  
  4497.     /* If we got one arg but it was just whitespace, call that 0 args.  */
  4498.     if (i == 1) {
  4499.       register U_CHAR *bp = args[0].raw;
  4500.       register U_CHAR *lim = bp + args[0].raw_length;
  4501.       while (bp != lim && is_space[*bp]) bp++;
  4502.       if (bp == lim)
  4503.     i = 0;
  4504.     }
  4505.  
  4506.     if (nargs == 0 && i > 0)
  4507.       error ("arguments given to macro `%s'", hp->name);
  4508.     else if (i < nargs) {
  4509.       /* traditional C allows foo() if foo wants one argument.  */
  4510.       if (nargs == 1 && i == 0 && traditional)
  4511.     ;
  4512.       else if (i == 0)
  4513.     error ("no args to macro `%s'", hp->name);
  4514.       else if (i == 1)
  4515.     error ("only 1 arg to macro `%s'", hp->name);
  4516.       else
  4517.     error ("only %d args to macro `%s'", i, hp->name);
  4518.     } else if (i > nargs)
  4519.       error ("too many (%d) args to macro `%s'", i, hp->name);
  4520.  
  4521.     /* Swallow the closeparen.  */
  4522.     ++instack[indepth].bufp;
  4523.  
  4524.     /* If macro wants zero args, we parsed the arglist for checking only.
  4525.        Read directly from the macro definition.  */
  4526.     if (nargs == 0) {
  4527.       xbuf = defn->expansion;
  4528.       xbuf_len = defn->length;
  4529.     } else {
  4530.       register U_CHAR *exp = defn->expansion;
  4531.       register int offset;    /* offset in expansion,
  4532.                    copied a piece at a time */
  4533.       register int totlen;    /* total amount of exp buffer filled so far */
  4534.  
  4535.       register struct reflist *ap;
  4536.  
  4537.       /* Macro really takes args.  Compute the expansion of this call.  */
  4538.  
  4539.       /* Compute length in characters of the macro's expansion.  */
  4540.       xbuf_len = defn->length;
  4541.       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
  4542.     if (ap->stringify)
  4543.       xbuf_len += args[ap->argno].stringified_length;
  4544.     else if (ap->raw_before || ap->raw_after)
  4545.       xbuf_len += args[ap->argno].raw_length;
  4546.     else
  4547.       xbuf_len += args[ap->argno].expand_length;
  4548.       }
  4549.  
  4550.       xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
  4551.  
  4552.       /* Generate in XBUF the complete expansion
  4553.      with arguments substituted in.
  4554.      TOTLEN is the total size generated so far.
  4555.      OFFSET is the index in the definition
  4556.      of where we are copying from.  */
  4557.       offset = totlen = 0;
  4558.       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
  4559.     register struct argdata *arg = &args[ap->argno];
  4560.  
  4561.     for (i = 0; i < ap->nchars; i++)
  4562.       xbuf[totlen++] = exp[offset++];
  4563.  
  4564.     if (ap->stringify != 0) {
  4565.       int arglen = arg->raw_length;
  4566.       int escaped = 0;
  4567.       int in_string = 0;
  4568.       int c;
  4569.       i = 0;
  4570.       while (i < arglen
  4571.          && (c = arg->raw[i], is_space[c]))
  4572.         i++;
  4573.       while (i < arglen
  4574.          && (c = arg->raw[arglen - 1], is_space[c]))
  4575.         arglen--;
  4576.       if (!traditional)
  4577.         xbuf[totlen++] = '\"'; /* insert beginning quote */
  4578.       for (; i < arglen; i++) {
  4579.         c = arg->raw[i];
  4580.  
  4581.         /* Special markers Newline Space
  4582.            generate nothing for a stringified argument.  */
  4583.         if (c == '\n' && arg->raw[i+1] != '\n') {
  4584.           i++;
  4585.           continue;
  4586.         }
  4587.  
  4588.         /* Internal sequences of whitespace are replaced by one space.  */
  4589.         if (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c]) {
  4590.           while (1) {
  4591.         if (c == '\n' && arg->raw[i+1] == '\n')
  4592.           i += 2;
  4593.         else if (c != '\n' && is_space[c])
  4594.           i++;
  4595.         else break;
  4596.         c = arg->raw[i];
  4597.           }
  4598.           i--;
  4599.           c = ' ';
  4600.         }
  4601.  
  4602.         if (escaped)
  4603.           escaped = 0;
  4604.         else {
  4605.           if (c == '\\')
  4606.         escaped = 1;
  4607.           if (in_string && c == in_string)
  4608.         in_string = 0;
  4609.           else if (c == '\"' || c == '\'')
  4610.         in_string = c;
  4611.         }
  4612.  
  4613.         /* Escape these chars */
  4614.         if (c == '\"' || (in_string && c == '\\'))
  4615.           xbuf[totlen++] = '\\';
  4616.         if (isprint (c))
  4617.           xbuf[totlen++] = c;
  4618.         else {
  4619.           sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c);
  4620.           totlen += 4;
  4621.         }
  4622.       }
  4623.       if (!traditional)
  4624.         xbuf[totlen++] = '\"'; /* insert ending quote */
  4625.     } else if (ap->raw_before || ap->raw_after) {
  4626.       U_CHAR *p1 = arg->raw;
  4627.       U_CHAR *l1 = p1 + arg->raw_length;
  4628.       if (ap->raw_before) {
  4629.         while (p1 != l1 && is_space[*p1]) p1++;
  4630.         while (p1 != l1 && is_idchar[*p1])
  4631.           xbuf[totlen++] = *p1++;
  4632.         /* Delete any no-reexpansion marker that follows
  4633.            an identifier at the beginning of the argument
  4634.            if the argument is concatenated with what precedes it.  */
  4635.         if (p1[0] == '\n' && p1[1] == '-')
  4636.           p1 += 2;
  4637.       }
  4638.       if (ap->raw_after) {
  4639.         /* Arg is concatenated after: delete trailing whitespace,
  4640.            whitespace markers, and no-reexpansion markers.  */
  4641.         while (p1 != l1) {
  4642.           if (is_space[l1[-1]]) l1--;
  4643.           else if (l1[-1] == '-') {
  4644.         U_CHAR *p2 = l1 - 1;
  4645.         /* If a `-' is preceded by an odd number of newlines then it
  4646.            and the last newline are a no-reexpansion marker.  */
  4647.         while (p2 != p1 && p2[-1] == '\n') p2--;
  4648.         if ((l1 - 1 - p2) & 1) {
  4649.           l1 -= 2;
  4650.         }
  4651.         else break;
  4652.           }
  4653.           else break;
  4654.         }
  4655.       }
  4656.       bcopy (p1, xbuf + totlen, l1 - p1);
  4657.       totlen += l1 - p1;
  4658.     } else {
  4659.       bcopy (arg->expanded, xbuf + totlen, arg->expand_length);
  4660.       totlen += arg->expand_length;
  4661.     }
  4662.  
  4663.     if (totlen > xbuf_len)
  4664.       abort ();
  4665.       }
  4666.  
  4667.       /* if there is anything left of the definition
  4668.      after handling the arg list, copy that in too. */
  4669.  
  4670.       for (i = offset; i < defn->length; i++)
  4671.     xbuf[totlen++] = exp[i];
  4672.  
  4673.       xbuf[totlen] = 0;
  4674.       xbuf_len = totlen;
  4675.  
  4676.       for (i = 0; i < nargs; i++) {
  4677.     if (args[i].free1 != 0)
  4678.       free (args[i].free1);
  4679.     if (args[i].free2 != 0)
  4680.       free (args[i].free2);
  4681.       }
  4682.     }
  4683.   } else {
  4684.     xbuf = defn->expansion;
  4685.     xbuf_len = defn->length;
  4686.   }
  4687.  
  4688.   /* Now put the expansion on the input stack
  4689.      so our caller will commence reading from it.  */
  4690.   {
  4691.     register FILE_BUF *ip2;
  4692.  
  4693.     ip2 = &instack[++indepth];
  4694.  
  4695.     ip2->fname = 0;
  4696.     ip2->lineno = 0;
  4697.     ip2->buf = xbuf;
  4698.     ip2->length = xbuf_len;
  4699.     ip2->bufp = xbuf;
  4700.     ip2->free_ptr = (nargs > 0) ? xbuf : 0;
  4701.     ip2->macro = hp;
  4702.     ip2->if_stack = if_stack;
  4703.  
  4704.     /* Recursive macro use sometimes works traditionally.
  4705.        #define foo(x,y) bar(x(y,0), y)
  4706.        foo(foo, baz)  */
  4707.  
  4708.     if (!traditional)
  4709.       hp->type = T_DISABLED;
  4710.   }
  4711. }
  4712.  
  4713. /*
  4714.  * Parse a macro argument and store the info on it into *ARGPTR.
  4715.  * Return nonzero to indicate a syntax error.
  4716.  */
  4717.  
  4718. char *
  4719. macarg (argptr)
  4720.      register struct argdata *argptr;
  4721. {
  4722.   FILE_BUF *ip = &instack[indepth];
  4723.   int paren = 0;
  4724.   int newlines = 0;
  4725.   int comments = 0;
  4726.  
  4727.   /* Try to parse as much of the argument as exists at this
  4728.      input stack level.  */
  4729.   U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
  4730.             &paren, &newlines, &comments);
  4731.  
  4732.   /* If we find the end of the argument at this level,
  4733.      set up *ARGPTR to point at it in the input stack.  */
  4734.   if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
  4735.       && bp != ip->buf + ip->length) {
  4736.     if (argptr != 0) {
  4737.       argptr->raw = ip->bufp;
  4738.       argptr->raw_length = bp - ip->bufp;
  4739.     }
  4740.     ip->bufp = bp;
  4741.   } else {
  4742.     /* This input stack level ends before the macro argument does.
  4743.        We must pop levels and keep parsing.
  4744.        Therefore, we must allocate a temporary buffer and copy
  4745.        the macro argument into it.  */
  4746.     int bufsize = bp - ip->bufp;
  4747.     int extra = newlines;
  4748.     U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
  4749.     int final_start = 0;
  4750.  
  4751.     bcopy (ip->bufp, buffer, bufsize);
  4752.     ip->bufp = bp;
  4753.     ip->lineno += newlines;
  4754.  
  4755.     while (bp == ip->buf + ip->length) {
  4756.       if (instack[indepth].macro == 0) {
  4757.     free (buffer);
  4758.     return "unterminated macro call";
  4759.       }
  4760.       ip->macro->type = T_MACRO;
  4761.       free (ip->buf);
  4762.       ip = &instack[--indepth];
  4763.       newlines = 0;
  4764.       comments = 0;
  4765.       bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
  4766.             &newlines, &comments);
  4767.       final_start = bufsize;
  4768.       bufsize += bp - ip->bufp;
  4769.       extra += newlines;
  4770.       buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
  4771.       bcopy (ip->bufp, buffer + bufsize - (bp - ip->bufp), bp - ip->bufp);
  4772.       ip->bufp = bp;
  4773.       ip->lineno += newlines;
  4774.     }
  4775.  
  4776.     /* Now, if arg is actually wanted, record its raw form,
  4777.        discarding comments and duplicating newlines in whatever
  4778.        part of it did not come from a macro expansion.
  4779.        EXTRA space has been preallocated for duplicating the newlines.
  4780.        FINAL_START is the index of the start of that part.  */
  4781.     if (argptr != 0) {
  4782.       argptr->raw = buffer;
  4783.       argptr->raw_length = bufsize;
  4784.       argptr->free1 = buffer;
  4785.       argptr->newlines = newlines;
  4786.       argptr->comments = comments;
  4787.       if ((newlines || comments) && ip->fname != 0)
  4788.     argptr->raw_length
  4789.       = final_start +
  4790.         discard_comments (argptr->raw + final_start,
  4791.                   argptr->raw_length - final_start,
  4792.                   newlines);
  4793.       argptr->raw[argptr->raw_length] = 0;
  4794.       if (argptr->raw_length > bufsize + extra)
  4795.     abort ();
  4796.     }
  4797.   }
  4798.  
  4799.   /* If we are not discarding this argument,
  4800.      macroexpand it and compute its length as stringified.
  4801.      All this info goes into *ARGPTR.  */
  4802.  
  4803.   if (argptr != 0) {
  4804.     FILE_BUF obuf;
  4805.     register U_CHAR *buf, *lim;
  4806.     register int totlen;
  4807.  
  4808.     obuf = expand_to_temp_buffer (argptr->raw,
  4809.                   argptr->raw + argptr->raw_length,
  4810.                   1);
  4811.  
  4812.     argptr->expanded = obuf.buf;
  4813.     argptr->expand_length = obuf.length;
  4814.     argptr->free2 = obuf.buf;
  4815.  
  4816.     buf = argptr->raw;
  4817.     lim = buf + argptr->raw_length;
  4818.  
  4819.     while (buf != lim && is_space[*buf])
  4820.       buf++;
  4821.     while (buf != lim && is_space[lim[-1]])
  4822.       lim--;
  4823.     totlen = traditional ? 0 : 2;    /* Count opening and closing quote.  */
  4824.     while (buf != lim) {
  4825.       register U_CHAR c = *buf++;
  4826.       totlen++;
  4827.       /* Internal sequences of whitespace are replaced by one space.  */
  4828.       if (is_space[c])
  4829.     SKIP_ALL_WHITE_SPACE (buf);
  4830.       else if (c == '\"' || c == '\\') /* escape these chars */
  4831.     totlen++;
  4832.       else if (!isprint (c))
  4833.     totlen += 3;
  4834.     }
  4835.     argptr->stringified_length = totlen;
  4836.   }
  4837.   return 0;
  4838. }
  4839.  
  4840. /* Scan text from START (inclusive) up to LIMIT (exclusive),
  4841.    counting parens in *DEPTHPTR,
  4842.    and return if reach LIMIT
  4843.    or before a `)' that would make *DEPTHPTR negative
  4844.    or before a comma when *DEPTHPTR is zero.
  4845.    Single and double quotes are matched and termination
  4846.    is inhibited within them.  Comments also inhibit it.
  4847.    Value returned is pointer to stopping place.
  4848.  
  4849.    Increment *NEWLINES each time a newline is passed.
  4850.    Set *COMMENTS to 1 if a comment is seen.  */
  4851.  
  4852. U_CHAR *
  4853. macarg1 (start, limit, depthptr, newlines, comments)
  4854.      U_CHAR *start;
  4855.      register U_CHAR *limit;
  4856.      int *depthptr, *newlines, *comments;
  4857. {
  4858.   register U_CHAR *bp = start;
  4859.  
  4860.   while (bp < limit) {
  4861.     switch (*bp) {
  4862.     case '(':
  4863.       (*depthptr)++;
  4864.       break;
  4865.     case ')':
  4866.       if (--(*depthptr) < 0)
  4867.     return bp;
  4868.       break;
  4869.     case '\\':
  4870.       /* Backslash makes following char not special.  */
  4871.       if (bp + 1 < limit)
  4872.     {
  4873.       bp++;
  4874.       /* But count source lines anyway.  */
  4875.       if (*bp == '\n')
  4876.         ++*newlines;
  4877.     }
  4878.       break;
  4879.     case '\n':
  4880.       ++*newlines;
  4881.       break;
  4882.     case '/':
  4883.       if (bp[1] == '\\' && bp[2] == '\n')
  4884.     newline_fix (bp + 1);
  4885.       if (cplusplus && bp[1] == '/') {
  4886.     *comments = 1;
  4887.     bp += 2;
  4888.     while (bp < limit && *bp++ != '\n') ;
  4889.     ++*newlines;
  4890.     break;
  4891.       }
  4892.       if (bp[1] != '*' || bp + 1 >= limit)
  4893.     break;
  4894.       *comments = 1;
  4895.       bp += 2;
  4896.       while (bp + 1 < limit) {
  4897.     if (bp[0] == '*'
  4898.         && bp[1] == '\\' && bp[2] == '\n')
  4899.       newline_fix (bp + 1);
  4900.     if (bp[0] == '*' && bp[1] == '/')
  4901.       break;
  4902.     if (*bp == '\n') ++*newlines;
  4903.     bp++;
  4904.       }
  4905.       break;
  4906.     case '\'':
  4907.     case '\"':
  4908.       {
  4909.     int quotec;
  4910.     for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
  4911.       if (*bp == '\\') {
  4912.         bp++;
  4913.         if (*bp == '\n')
  4914.           ++*newlines;
  4915.         while (*bp == '\\' && bp[1] == '\n') {
  4916.           bp += 2;
  4917.         }
  4918.       } else if (*bp == '\n') {
  4919.         ++*newlines;
  4920.         if (quotec == '\'')
  4921.           break;
  4922.       }
  4923.     }
  4924.       }
  4925.       break;
  4926.     case ',':
  4927.       if ((*depthptr) == 0)
  4928.     return bp;
  4929.       break;
  4930.     }
  4931.     bp++;
  4932.   }
  4933.  
  4934.   return bp;
  4935. }
  4936.  
  4937. /* Discard comments and duplicate newlines
  4938.    in the string of length LENGTH at START,
  4939.    except inside of string constants.
  4940.    The string is copied into itself with its beginning staying fixed.  
  4941.  
  4942.    NEWLINES is the number of newlines that must be duplicated.
  4943.    We assume that that much extra space is available past the end
  4944.    of the string.  */
  4945.  
  4946. int
  4947. discard_comments (start, length, newlines)
  4948.      U_CHAR *start;
  4949.      int length;
  4950.      int newlines;
  4951. {
  4952.   register U_CHAR *ibp;
  4953.   register U_CHAR *obp;
  4954.   register U_CHAR *limit;
  4955.   register int c;
  4956.  
  4957.   /* If we have newlines to duplicate, copy everything
  4958.      that many characters up.  Then, in the second part,
  4959.      we will have room to insert the newlines
  4960.      while copying down.
  4961.      NEWLINES may actually be too large, because it counts
  4962.      newlines in string constants, and we don't duplicate those.
  4963.      But that does no harm.  */
  4964.   if (newlines > 0) {
  4965.     ibp = start + length;
  4966.     obp = ibp + newlines;
  4967.     limit = start;
  4968.     while (limit != ibp)
  4969.       *--obp = *--ibp;
  4970.   }
  4971.  
  4972.   ibp = start + newlines;
  4973.   limit = start + length + newlines;
  4974.   obp = start;
  4975.  
  4976.   while (ibp < limit) {
  4977.     *obp++ = c = *ibp++;
  4978.     switch (c) {
  4979.     case '\n':
  4980.       /* Duplicate the newline.  */
  4981.       *obp++ = '\n';
  4982.       break;
  4983.  
  4984.     case '/':
  4985.       if (*ibp == '\\' && ibp[1] == '\n')
  4986.     newline_fix (ibp);
  4987.       /* Delete any comment.  */
  4988.       if (cplusplus && ibp[0] == '/') {
  4989.     obp--;
  4990.     ibp++;
  4991.     while (ibp < limit && *ibp++ != '\n') ;
  4992.     break;
  4993.       }
  4994.       if (ibp[0] != '*' || ibp + 1 >= limit)
  4995.     break;
  4996.       obp--;
  4997.       ibp++;
  4998.       while (ibp + 1 < limit) {
  4999.     if (ibp[0] == '*'
  5000.         && ibp[1] == '\\' && ibp[2] == '\n')
  5001.       newline_fix (ibp + 1);
  5002.     if (ibp[0] == '*' && ibp[1] == '/')
  5003.       break;
  5004.     ibp++;
  5005.       }
  5006.       ibp += 2;
  5007.       break;
  5008.  
  5009.     case '\'':
  5010.     case '\"':
  5011.       /* Notice and skip strings, so that we don't
  5012.      think that comments start inside them,
  5013.      and so we don't duplicate newlines in them.  */
  5014.       {
  5015.     int quotec = c;
  5016.     while (ibp < limit) {
  5017.       *obp++ = c = *ibp++;
  5018.       if (c == quotec)
  5019.         break;
  5020.       if (c == '\n' && quotec == '\'')
  5021.         break;
  5022.       if (c == '\\' && ibp < limit) {
  5023.         while (*ibp == '\\' && ibp[1] == '\n')
  5024.           ibp += 2;
  5025.         *obp++ = *ibp++;
  5026.       }
  5027.     }
  5028.       }
  5029.       break;
  5030.     }
  5031.   }
  5032.  
  5033.   return obp - start;
  5034. }
  5035.  
  5036. /*
  5037.  * error - print error message and increment count of errors.
  5038.  */
  5039. #if ! defined( _MSDOS )
  5040. error (msg, arg1, arg2, arg3)
  5041.      char *msg;
  5042. #else
  5043. int error ( char * msg, ... )
  5044. #endif
  5045. {
  5046.     int i;
  5047.     FILE_BUF *ip = NULL;
  5048. #if defined (_MSDOS )
  5049.     int arg1, arg2, arg3;
  5050.     va_list ap;
  5051.     
  5052.     va_start( ap, msg );
  5053.  
  5054.     /* make the faulty assumption that arg1 - arg3 exist */
  5055.     arg1 = va_arg( ap, int );
  5056.     arg2 = va_arg( ap, int );
  5057.     arg3 = va_arg( ap, int );
  5058. #endif
  5059.  
  5060.     for (i = indepth; i >= 0; i--)
  5061.     if (instack[i].fname != NULL)
  5062.     {
  5063.         ip = &instack[i];
  5064.         break;
  5065.     }
  5066.  
  5067.     if (ip != NULL)
  5068.     fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
  5069.  
  5070.     fprintf (stderr, msg, arg1, arg2, arg3);
  5071.     fprintf (stderr, "\n");
  5072.     errors++;
  5073. #if defined (_MSDOS )
  5074.     va_end( ap );
  5075. #endif
  5076.     return 0;
  5077. }
  5078.  
  5079. /* Error including a message from `errno'.  */
  5080.  
  5081. error_from_errno (name)
  5082.      char *name;
  5083. {
  5084.   int i;
  5085.   FILE_BUF *ip = NULL;
  5086. #if ! defined( _INTELC32_ ) && ! defined( __WATCOMC__ )
  5087.   extern int errno;
  5088. #endif
  5089. #if ! defined( __WATCOMC__ )
  5090.   extern int sys_nerr;
  5091. #endif
  5092.   extern char *sys_errlist[];
  5093.  
  5094.   for (i = indepth; i >= 0; i--)
  5095.     if (instack[i].fname != NULL) {
  5096.       ip = &instack[i];
  5097.       break;
  5098.     }
  5099.  
  5100.   if (ip != NULL)
  5101.     fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
  5102.  
  5103.   if (errno < sys_nerr)
  5104.     fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
  5105.   else
  5106.     fprintf (stderr, "%s: undocumented I/O error\n", name);
  5107.  
  5108.   errors++;
  5109.   return 0;
  5110. }
  5111.  
  5112. /* Print error message but don't count it.  */
  5113.  
  5114. #if ! defined( _MSDOS )
  5115. warning (msg, arg1, arg2, arg3)
  5116.      char *msg;
  5117. #else
  5118. warning ( char * msg, ... )
  5119. #endif
  5120. {
  5121.   int i;
  5122.   FILE_BUF *ip = NULL;
  5123. #if defined (_MSDOS )
  5124.     int arg1, arg2, arg3;
  5125.     va_list ap;
  5126.     
  5127.     va_start( ap, msg );
  5128.  
  5129.     /* make the faulty assumption that arg1 - arg3 exist */
  5130.     arg1 = va_arg( ap, int );
  5131.     arg2 = va_arg( ap, int );
  5132.     arg3 = va_arg( ap, int );
  5133. #endif
  5134.  
  5135.   for (i = indepth; i >= 0; i--)
  5136.     if (instack[i].fname != NULL) {
  5137.       ip = &instack[i];
  5138.       break;
  5139.     }
  5140.  
  5141.   if (ip != NULL)
  5142.     fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
  5143.   fprintf (stderr, "warning: ");
  5144.   fprintf (stderr, msg, arg1, arg2, arg3);
  5145.   fprintf (stderr, "\n");
  5146. #if defined (_MSDOS )
  5147.     va_end( ap );
  5148. #endif
  5149.   return 0;
  5150. }
  5151.  
  5152. #if ! defined( _MSDOS )
  5153. error_with_line (line, msg, arg1, arg2, arg3)
  5154.      int line;
  5155.      char *msg;
  5156. #else
  5157. error_with_line ( int line, char * msg, ... )
  5158. #endif
  5159. {
  5160.     int i;
  5161.     FILE_BUF *ip = NULL;
  5162. #if defined (_MSDOS )
  5163.     int arg1, arg2, arg3;
  5164.     va_list ap;
  5165.     
  5166.     va_start( ap, msg );
  5167.  
  5168.     /* make the faulty assumption that arg1 - arg3 exist */
  5169.     arg1 = va_arg( ap, int );
  5170.     arg2 = va_arg( ap, int );
  5171.     arg3 = va_arg( ap, int );
  5172. #endif
  5173.  
  5174.   for (i = indepth; i >= 0; i--)
  5175.     if (instack[i].fname != NULL) {
  5176.       ip = &instack[i];
  5177.       break;
  5178.     }
  5179.  
  5180.   if (ip != NULL)
  5181.     fprintf (stderr, "%s:%d: ", ip->fname, line);
  5182.   fprintf (stderr, msg, arg1, arg2, arg3);
  5183.   fprintf (stderr, "\n");
  5184.   errors++;
  5185. #if defined (_MSDOS )
  5186.     va_end( ap );
  5187. #endif
  5188.   return 0;
  5189. }
  5190.  
  5191. /* Return the line at which an error occurred.
  5192.    The error is not necessarily associated with the current spot
  5193.    in the input stack, so LINE says where.  LINE will have been
  5194.    copied from ip->lineno for the current input level.
  5195.    If the current level is for a file, we return LINE.
  5196.    But if the current level is not for a file, LINE is meaningless.
  5197.    In that case, we return the lineno of the innermost file.  */
  5198. int
  5199. line_for_error (line)
  5200.      int line;
  5201. {
  5202.   int i;
  5203.   int line1 = line;
  5204.  
  5205.   for (i = indepth; i >= 0; ) {
  5206.     if (instack[i].fname != 0)
  5207.       return line1;
  5208.     i--;
  5209.     if (i < 0)
  5210.       return 0;
  5211.     line1 = instack[i].lineno;
  5212.   }
  5213. }
  5214.  
  5215. /*
  5216.  * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
  5217.  *
  5218.  * As things stand, nothing is ever placed in the output buffer to be
  5219.  * removed again except when it's KNOWN to be part of an identifier,
  5220.  * so flushing and moving down everything left, instead of expanding,
  5221.  * should work ok.
  5222.  */
  5223.  
  5224. int
  5225. grow_outbuf (obuf, needed)
  5226.      register FILE_BUF *obuf;
  5227.      register int needed;
  5228. {
  5229.   register U_CHAR *p;
  5230.   int minsize;
  5231.  
  5232.   if (obuf->length - (obuf->bufp - obuf->buf) > needed)
  5233.     return;
  5234.  
  5235.   /* Make it at least twice as big as it is now.  */
  5236.   obuf->length *= 2;
  5237.   /* Make it have at least 150% of the free space we will need.  */
  5238.   minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
  5239.   if (minsize > obuf->length)
  5240.     obuf->length = minsize;
  5241.  
  5242.   if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
  5243.     memory_full ();
  5244.  
  5245.   obuf->bufp = p + (obuf->bufp - obuf->buf);
  5246.   obuf->buf = p;
  5247. }
  5248.  
  5249. /* Symbol table for macro names and special symbols */
  5250.  
  5251. /*
  5252.  * install a name in the main hash table, even if it is already there.
  5253.  *   name stops with first non alphanumeric, except leading '#'.
  5254.  * caller must check against redefinition if that is desired.
  5255.  * delete_macro () removes things installed by install () in fifo order.
  5256.  * this is important because of the `defined' special symbol used
  5257.  * in #if, and also if pushdef/popdef directives are ever implemented.
  5258.  *
  5259.  * If LEN is >= 0, it is the length of the name.
  5260.  * Otherwise, compute the length by scanning the entire name.
  5261.  *
  5262.  * If HASH is >= 0, it is the precomputed hash code.
  5263.  * Otherwise, compute the hash code.
  5264.  */
  5265. HASHNODE *
  5266. install (name, len, type, value, hash)
  5267.      U_CHAR *name;
  5268.      int len;
  5269.      enum node_type type;
  5270.      int value;
  5271.      int hash;
  5272.         /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
  5273. {
  5274.   register HASHNODE *hp;
  5275.   register int i, bucket;
  5276.   register U_CHAR *p, *q;
  5277.  
  5278.   if (len < 0) {
  5279.     p = name;
  5280.     while (is_idchar[*p])
  5281.       p++;
  5282.     len = p - name;
  5283.   }
  5284.  
  5285.   if (hash < 0)
  5286.     hash = hashf (name, len, HASHSIZE);
  5287.  
  5288.   i = sizeof (HASHNODE) + len + 1;
  5289.   hp = (HASHNODE *) xmalloc (i);
  5290.   bucket = hash;
  5291.   hp->bucket_hdr = &hashtab[bucket];
  5292.   hp->next = hashtab[bucket];
  5293.   hashtab[bucket] = hp;
  5294.   hp->prev = NULL;
  5295.   if (hp->next != NULL)
  5296.     hp->next->prev = hp;
  5297.   hp->type = type;
  5298.   hp->length = len;
  5299.   hp->value.ival = value;
  5300.   hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
  5301.   p = hp->name;
  5302.   q = name;
  5303.   for (i = 0; i < len; i++)
  5304.     *p++ = *q++;
  5305.   hp->name[len] = 0;
  5306.   return hp;
  5307. }
  5308.  
  5309. /*
  5310.  * find the most recent hash node for name name (ending with first
  5311.  * non-identifier char) installed by install
  5312.  *
  5313.  * If LEN is >= 0, it is the length of the name.
  5314.  * Otherwise, compute the length by scanning the entire name.
  5315.  *
  5316.  * If HASH is >= 0, it is the precomputed hash code.
  5317.  * Otherwise, compute the hash code.
  5318.  */
  5319. HASHNODE *
  5320. lookup (name, len, hash)
  5321.      U_CHAR *name;
  5322.      int len;
  5323.      int hash;
  5324. {
  5325.   register U_CHAR *bp;
  5326.   register HASHNODE *bucket;
  5327.  
  5328.   if (len < 0) {
  5329.     for (bp = name; is_idchar[*bp]; bp++) ;
  5330.     len = bp - name;
  5331.   }
  5332.  
  5333.   if (hash < 0)
  5334.     hash = hashf (name, len, HASHSIZE);
  5335.  
  5336.   bucket = hashtab[hash];
  5337.   while (bucket) {
  5338. #if defined( NeXT )
  5339.     if (bucket->length == len && strncmp ((char*)bucket->name, (char*)name, len) == 0)
  5340. #else
  5341.     if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
  5342. #endif
  5343.       return bucket;
  5344.     bucket = bucket->next;
  5345.   }
  5346.   return NULL;
  5347. }
  5348.  
  5349. /*
  5350.  * Delete a hash node.  Some weirdness to free junk from macros.
  5351.  * More such weirdness will have to be added if you define more hash
  5352.  * types that need it.
  5353.  */
  5354.  
  5355. /* Note that the DEFINITION of a macro is removed from the hash table
  5356.    but its storage is not freed.  This would be a storage leak
  5357.    except that it is not reasonable to keep undefining and redefining
  5358.    large numbers of macros many times.
  5359.    In any case, this is necessary, because a macro can be #undef'd
  5360.    in the middle of reading the arguments to a call to it.
  5361.    If #undef freed the DEFINITION, that would crash.  */
  5362.  
  5363. delete_macro (hp)
  5364.      HASHNODE *hp;
  5365. {
  5366.  
  5367.   if (hp->prev != NULL)
  5368.     hp->prev->next = hp->next;
  5369.   if (hp->next != NULL)
  5370.     hp->next->prev = hp->prev;
  5371.  
  5372.   /* make sure that the bucket chain header that
  5373.      the deleted guy was on points to the right thing afterwards. */
  5374.   if (hp == *hp->bucket_hdr)
  5375.     *hp->bucket_hdr = hp->next;
  5376.  
  5377. #if 0
  5378.   if (hp->type == T_MACRO) {
  5379.     DEFINITION *d = hp->value.defn;
  5380.     struct reflist *ap, *nextap;
  5381.  
  5382.     for (ap = d->pattern; ap != NULL; ap = nextap) {
  5383.       nextap = ap->next;
  5384.       free (ap);
  5385.     }
  5386.     free (d);
  5387.   }
  5388. #endif
  5389.   free (hp);
  5390. }
  5391.  
  5392. /*
  5393.  * return hash function on name.  must be compatible with the one
  5394.  * computed a step at a time, elsewhere
  5395.  */
  5396. int
  5397. hashf (name, len, hashsize)
  5398.      register U_CHAR *name;
  5399.      register int len;
  5400.      int hashsize;
  5401. {
  5402.   register int r = 0;
  5403.  
  5404.   while (len--)
  5405.     r = HASHSTEP (r, *name++);
  5406.  
  5407.   return MAKE_POS (r) % hashsize;
  5408. }
  5409.  
  5410. /* Dump all macro definitions as #defines to stdout.  */
  5411.  
  5412. void
  5413. dump_all_macros ()
  5414. {
  5415.   int bucket;
  5416.  
  5417.   for (bucket = 0; bucket < HASHSIZE; bucket++) {
  5418.     register HASHNODE *hp;
  5419.  
  5420.     for (hp = hashtab[bucket]; hp; hp= hp->next) {
  5421.       if (hp->type == T_MACRO) {
  5422.     register DEFINITION *defn = hp->value.defn;
  5423.     struct reflist *ap;
  5424.     int offset;
  5425.     int concat;
  5426.  
  5427.  
  5428.     /* Print the definition of the macro HP.  */
  5429.  
  5430.     printf ("#define %s", hp->name);
  5431.     if (defn->nargs >= 0) {
  5432.       int i;
  5433.  
  5434.       printf ("(");
  5435.       for (i = 0; i < defn->nargs; i++) {
  5436.         dump_arg_n (defn, i);
  5437.         if (i + 1 < defn->nargs)
  5438.           printf (", ");
  5439.       }
  5440.       printf (")");
  5441.     }
  5442.  
  5443.     printf (" ");
  5444.  
  5445.     offset = 0;
  5446.     concat = 0;
  5447.     for (ap = defn->pattern; ap != NULL; ap = ap->next) {
  5448.       dump_defn_1 (defn->expansion, offset, ap->nchars);
  5449.       if (ap->nchars != 0)
  5450.         concat = 0;
  5451.       offset += ap->nchars;
  5452.       if (ap->stringify)
  5453.         printf (" #");
  5454.       if (ap->raw_before && !concat)
  5455.         printf (" ## ");
  5456.       concat = 0;
  5457.       dump_arg_n (defn, ap->argno);
  5458.       if (ap->raw_after) {
  5459.         printf (" ## ");
  5460.         concat = 1;
  5461.       }
  5462.     }
  5463.     dump_defn_1 (defn->expansion, offset, defn->length - offset);
  5464.     printf ("\n");
  5465.       }
  5466.     }
  5467.   }
  5468. }
  5469.  
  5470. /* Output to stdout a substring of a macro definition.
  5471.    BASE is the beginning of the definition.
  5472.    Output characters START thru LENGTH.
  5473.    Discard newlines outside of strings, thus
  5474.    converting funny-space markers to ordinary spaces.  */
  5475.  
  5476. dump_defn_1 (base, start, length)
  5477.      U_CHAR *base;
  5478.      int start;
  5479.      int length;
  5480. {
  5481.   U_CHAR *p = base + start;
  5482.   U_CHAR *limit = base + start + length;
  5483.  
  5484.   while (p < limit) {
  5485.     if (*p != '\n')
  5486.       putchar (*p);
  5487.     else if (*p == '\"' || *p =='\'') {
  5488.       U_CHAR *p1 = skip_quoted_string (p, limit, 0, 0, 0, 0);
  5489.       fwrite (p, p1 - p, 1, stdout);
  5490.       p = p1 - 1;
  5491.     }
  5492.     p++;
  5493.   }
  5494. }
  5495.  
  5496. /* Print the name of argument number ARGNUM of macro definition DEFN.
  5497.    Recall that DEFN->argnames contains all the arg names
  5498.    concatenated in reverse order with comma-space in between.  */
  5499.  
  5500. dump_arg_n (defn, argnum)
  5501.      DEFINITION *defn;
  5502.      int argnum;
  5503. {
  5504.   register U_CHAR *p = defn->argnames;
  5505.   while (argnum + 1 < defn->nargs) {
  5506. #if defined( NeXT )
  5507.     p = (U_CHAR *) index ((char*)p, ' ') + 1;
  5508. #else
  5509.     p = (U_CHAR *) index (p, ' ') + 1;
  5510. #endif
  5511.     argnum++;
  5512.   }
  5513.  
  5514.   while (*p && *p != ',') {
  5515.     putchar (*p);
  5516.     p++;
  5517.   }
  5518. }
  5519.  
  5520. /* Initialize syntactic classifications of characters.  */
  5521.  
  5522. initialize_char_syntax ()
  5523. {
  5524.   register int i;
  5525.  
  5526.   /*
  5527.    * Set up is_idchar and is_idstart tables.  These should be
  5528.    * faster than saying (is_alpha (c) || c == '_'), etc.
  5529.    * Must do set up these things before calling any routines tthat
  5530.    * refer to them.
  5531.    */
  5532.   for (i = 'a'; i <= 'z'; i++) {
  5533.     is_idchar[i - 'a' + 'A'] = 1;
  5534.     is_idchar[i] = 1;
  5535.     is_idstart[i - 'a' + 'A'] = 1;
  5536.     is_idstart[i] = 1;
  5537.   }
  5538.   for (i = '0'; i <= '9'; i++)
  5539.     is_idchar[i] = 1;
  5540.   is_idchar['_'] = 1;
  5541.   is_idstart['_'] = 1;
  5542.   is_idchar['$'] = dollars_in_ident;
  5543.   is_idstart['$'] = dollars_in_ident;
  5544.  
  5545.   /* horizontal space table */
  5546.   is_hor_space[' '] = 1;
  5547.   is_hor_space['\t'] = 1;
  5548.   is_hor_space['\v'] = 1;
  5549.   is_hor_space['\f'] = 1;
  5550.  
  5551.   is_space[' '] = 1;
  5552.   is_space['\t'] = 1;
  5553.   is_space['\v'] = 1;
  5554.   is_space['\f'] = 1;
  5555.   is_space['\n'] = 1;
  5556. }
  5557.  
  5558. /* Initialize the built-in macros.  */
  5559.  
  5560. initialize_builtins ()
  5561. {
  5562.   install ("__LINE__", -1, T_SPECLINE, 0, -1);
  5563.   install ("__DATE__", -1, T_DATE, 0, -1);
  5564.   install ("__FILE__", -1, T_FILE, 0, -1);
  5565.   install ("__BASE_FILE__", -1, T_BASE_FILE, 0, -1);
  5566.   install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, -1);
  5567.   install ("__VERSION__", -1, T_VERSION, 0, -1);
  5568.   install ("__TIME__", -1, T_TIME, 0, -1);
  5569.   if (!traditional)
  5570.     install ("__STDC__", -1, T_CONST, 1, -1);
  5571. /*  install ("__GNU__", -1, T_CONST, 1, -1);  */
  5572. /*  This is supplied using a -D by the compiler driver
  5573.     so that it is present only when truly compiling with GNU C.  */
  5574. }
  5575.  
  5576. /*
  5577.  * process a given definition string, for initialization
  5578.  * If STR is just an identifier, define it with value 1.
  5579.  * If STR has anything after the identifier, then it should
  5580.  * be identifier-space-definition.
  5581.  */
  5582. make_definition (str)
  5583.      U_CHAR *str;
  5584. {
  5585.   FILE_BUF *ip;
  5586.   struct directive *kt;
  5587.   U_CHAR *buf, *p;
  5588.  
  5589.   buf = str;
  5590.   p = str;
  5591.   while (is_idchar[*p]) p++;
  5592.   if (p == str) {
  5593.     error ("malformed option `-D %s'", str);
  5594.     return;
  5595.   }
  5596.   if (*p == 0) {
  5597.     buf = (U_CHAR *) alloca (p - buf + 4);
  5598. #if defined( NeXT )
  5599.     strcpy ((char *)buf, (char*)str);
  5600. #else
  5601.     strcpy ((char *)buf, str);
  5602. #endif
  5603.     strcat ((char *)buf, " 1");
  5604.   } else if (*p != ' ') {
  5605.     error ("malformed option `-D %s'", str);
  5606.     return;
  5607.   }
  5608.   
  5609.   ip = &instack[++indepth];
  5610.   ip->fname = "*Initialization*";
  5611.  
  5612.   ip->buf = ip->bufp = buf;
  5613. #if defined( NeXT )
  5614.   ip->length = strlen ((char*)buf);
  5615. #else
  5616.   ip->length = strlen (buf);
  5617. #endif
  5618.   ip->lineno = 1;
  5619.   ip->macro = 0;
  5620.   ip->free_ptr = 0;
  5621.   ip->if_stack = if_stack;
  5622.  
  5623.   for (kt = directive_table; kt->type != T_DEFINE; kt++)
  5624.     ;
  5625.  
  5626.   /* pass NULL as output ptr to do_define since we KNOW it never
  5627.      does any output.... */
  5628. #if defined( NeXT )
  5629.   do_define (buf, buf + strlen ((char*)buf) , NULL, kt);
  5630. #else
  5631.   do_define (buf, buf + strlen (buf) , NULL, kt);
  5632. #endif
  5633.   --indepth;
  5634. }
  5635.  
  5636. /* JF, this does the work for the -U option */
  5637. make_undef (str)
  5638.      U_CHAR *str;
  5639. {
  5640.   FILE_BUF *ip;
  5641.   struct directive *kt;
  5642.  
  5643.   ip = &instack[++indepth];
  5644.   ip->fname = "*undef*";
  5645.  
  5646.   ip->buf = ip->bufp = str;
  5647. #if defined( NeXT )
  5648.   ip->length = strlen ((char*)str);
  5649. #else
  5650.   ip->length = strlen (str);
  5651. #endif
  5652.   ip->lineno = 1;
  5653.   ip->macro = 0;
  5654.   ip->free_ptr = 0;
  5655.   ip->if_stack = if_stack;
  5656.  
  5657.   for (kt = directive_table; kt->type != T_UNDEF; kt++)
  5658.     ;
  5659.  
  5660. #if defined( NeXT )
  5661.   do_undef (str,str + strlen ((char*)str) - 1, NULL, kt);
  5662. #else
  5663.   do_undef (str,str + strlen (str) - 1, NULL, kt);
  5664. #endif
  5665.   --indepth;
  5666. }
  5667.  
  5668. /* Add output to `deps_buffer' for the -M switch.
  5669.    STRING points to the text to be output.
  5670.    SIZE is the number of bytes, or 0 meaning output until a null.
  5671.    If SIZE is nonzero, we break the line first, if it is long enough.  */
  5672.  
  5673. deps_output (string, size)
  5674.      char *string;
  5675.      int size;
  5676. {
  5677. #ifndef MAX_OUTPUT_COLUMNS
  5678. #define MAX_OUTPUT_COLUMNS 75
  5679. #endif
  5680.   if (size != 0 && deps_column != 0
  5681.       && size + deps_column > MAX_OUTPUT_COLUMNS) {
  5682.     deps_output ("\\\n  ", 0);
  5683.     deps_column = 0;
  5684.   }
  5685.  
  5686.   if (size == 0)
  5687.     size = strlen (string);
  5688.  
  5689.   if (deps_size + size + 1 > deps_allocated_size) {
  5690.     deps_allocated_size = deps_size + size + 50;
  5691.     deps_allocated_size *= 2;
  5692.     deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
  5693.   }
  5694.   bcopy (string, &deps_buffer[deps_size], size);
  5695.   deps_size += size;
  5696.   deps_column += size;
  5697.   deps_buffer[deps_size] = 0;
  5698. }
  5699.  
  5700. #if ! defined( NeXT )
  5701. #ifndef GNUDOS
  5702. #ifndef BSD
  5703. #ifndef BSTRING
  5704.  
  5705. void
  5706. bzero (b, length)
  5707.      register char *b;
  5708.      register int length;
  5709. {
  5710. #ifdef VMS
  5711.   short zero = 0;
  5712.   long max_str = 65535;
  5713.  
  5714.   while (length > max_str) {
  5715.     (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
  5716.     length -= max_str;
  5717.     b += max_str;
  5718.   }
  5719.   (void) LIB$MOVC5 (&zero, &zero, &zero, &length, b);
  5720. #else
  5721.   while (length-- > 0)
  5722.     *b++ = 0;
  5723. #endif /* not VMS */
  5724. }
  5725.  
  5726. void
  5727. bcopy (b1, b2, length)
  5728.      register char *b1;
  5729.      register char *b2;
  5730.      register int length;
  5731. {
  5732. #ifdef VMS
  5733.   long max_str = 65535;
  5734.  
  5735.   while (length > max_str) {
  5736.     (void) LIB$MOVC3 (&max_str, b1, b2);
  5737.     length -= max_str;
  5738.     b1 += max_str;
  5739.     b2 += max_str;
  5740.   }
  5741.   (void) LIB$MOVC3 (&length, b1, b2);
  5742. #else
  5743.   while (length-- > 0)
  5744.     *b2++ = *b1++;
  5745. #endif /* not VMS */
  5746. }
  5747.  
  5748. int
  5749. bcmp (b1, b2, length)    /* This could be a macro! */
  5750.      register char *b1;
  5751.      register char *b2;
  5752.       register int length;
  5753. {
  5754. #ifdef VMS
  5755.    struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
  5756.    struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
  5757.  
  5758.    return STR$COMPARE (&src1, &src2);
  5759. #else
  5760.    while (length-- > 0)
  5761.      if (*b1++ != *b2++)
  5762.        return 1;
  5763.  
  5764.    return 0;
  5765. #endif /* not VMS */
  5766. }
  5767. #endif /* not BSTRING */
  5768. #endif /* not BSD */
  5769. #endif /* not GNUDOS */
  5770. #endif /* not NeXT */
  5771.  
  5772.  
  5773. #if ! defined( _MSDOS )
  5774. void
  5775. fatal (str, arg)
  5776.      char *str, *arg;
  5777. #else
  5778. void fatal ( char *str, ... )
  5779. #endif
  5780. {
  5781. #if defined (_MSDOS )
  5782.     int arg;
  5783.     va_list ap;
  5784.     
  5785.     va_start( ap, str );
  5786.  
  5787.     /* make the faulty assumption that arg exists */
  5788.     arg = va_arg( ap, char * );
  5789. #endif
  5790.   fprintf (stderr, "%s: ", progname);
  5791.   fprintf (stderr, str, arg);
  5792.   fprintf (stderr, "\n");
  5793. #if defined (_MSDOS )
  5794.     va_end( ap );
  5795. #endif
  5796.   exit (FATAL_EXIT_CODE);
  5797. }
  5798.  
  5799. /* More 'friendly' abort that prints the line and file.
  5800.    config.h can #define abort fancy_abort if you like that sort of thing.  */
  5801.  
  5802. void
  5803. fancy_abort ()
  5804. {
  5805.   fatal ("Internal gcc abort.");
  5806. }
  5807.  
  5808. void
  5809. perror_with_name (name)
  5810.      char *name;
  5811. {
  5812. #if ! defined( _INTELC32_ ) && ! defined( __WATCOMC__ )
  5813.   extern int errno;
  5814. #endif
  5815. #if ! defined( __WATCOMC__ )
  5816.   extern int sys_nerr;
  5817. #endif
  5818.   extern char *sys_errlist[];
  5819.  
  5820.   fprintf (stderr, "%s: ", progname);
  5821.   if (errno < sys_nerr)
  5822.     fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
  5823.   else
  5824.     fprintf (stderr, "%s: undocumented I/O error\n", name);
  5825.   errors++;
  5826. }
  5827.  
  5828. void
  5829. pfatal_with_name (name)
  5830.      char *name;
  5831. {
  5832.   perror_with_name (name);
  5833. #ifdef VMS
  5834.   exit (vaxc$errno);
  5835. #else
  5836.   exit (FATAL_EXIT_CODE);
  5837. #endif
  5838. }
  5839.  
  5840.  
  5841. void
  5842. memory_full ()
  5843. {
  5844.   fatal ("Memory exhausted.");
  5845. }
  5846.  
  5847.  
  5848. #if defined( _MSDOS )
  5849. /* Meta Ware is correct here. */
  5850. void *
  5851. xmalloc (size)
  5852.      int size;
  5853. {
  5854.   extern void *malloc ();
  5855.   register void *ptr = malloc (size);
  5856.   if (ptr != 0) return (ptr);
  5857.   memory_full ();
  5858.   /*NOTREACHED*/
  5859. }
  5860.  
  5861. void *
  5862. xrealloc (old, size)
  5863.      void *old;
  5864.      int size;
  5865. {
  5866.   extern void *realloc ();
  5867.   register void *ptr = realloc (old, size);
  5868.   if (ptr != 0) return (ptr);
  5869.   memory_full ();
  5870.   /*NOTREACHED*/
  5871. }
  5872.  
  5873. void *
  5874. xcalloc (number, size)
  5875.      int number, size;
  5876. {
  5877.   extern void *malloc ();
  5878.   register int total = number * size;
  5879.   register void *ptr = malloc (total);
  5880.   if (ptr != 0) {
  5881.     if (total > 100)
  5882.       bzero (ptr, total);
  5883.     else {
  5884.       /* It's not too long, so loop, zeroing by longs.
  5885.      It must be safe because malloc values are always well aligned.  */
  5886.       register long *zp = (long *) ptr;
  5887.       register long *zl = (long *) (((char*)ptr) + total - 4);
  5888.       register int i = total - 4;
  5889.       while (zp < zl)
  5890.     *zp++ = 0;
  5891.       if (i < 0)
  5892.     i = 0;
  5893.       while (i < total)
  5894.     ((char*)ptr)[i++] = 0;
  5895.     }
  5896.     return ptr;
  5897.   }
  5898.   memory_full ();
  5899.   /*NOTREACHED*/
  5900. }
  5901. #else
  5902. char *
  5903. xmalloc (size)
  5904.      int size;
  5905. {
  5906.   extern char *malloc ();
  5907.   register char *ptr = malloc (size);
  5908.   if (ptr != 0) return (ptr);
  5909.   memory_full ();
  5910.   /*NOTREACHED*/
  5911. }
  5912.  
  5913. char *
  5914. xrealloc (old, size)
  5915.      char *old;
  5916.      int size;
  5917. {
  5918.   extern char *realloc ();
  5919.   register char *ptr = realloc (old, size);
  5920.   if (ptr != 0) return (ptr);
  5921.   memory_full ();
  5922.   /*NOTREACHED*/
  5923. }
  5924.  
  5925. char *
  5926. xcalloc (number, size)
  5927.      int number, size;
  5928. {
  5929.   extern char *malloc ();
  5930.   register int total = number * size;
  5931.   register char *ptr = malloc (total);
  5932.   if (ptr != 0) {
  5933.     if (total > 100)
  5934.       bzero (ptr, total);
  5935.     else {
  5936.       /* It's not too long, so loop, zeroing by longs.
  5937.      It must be safe because malloc values are always well aligned.  */
  5938.       register long *zp = (long *) ptr;
  5939.       register long *zl = (long *) (ptr + total - 4);
  5940.       register int i = total - 4;
  5941.       while (zp < zl)
  5942.     *zp++ = 0;
  5943.       if (i < 0)
  5944.     i = 0;
  5945.       while (i < total)
  5946.     ptr[i++] = 0;
  5947.     }
  5948.     return ptr;
  5949.   }
  5950.   memory_full ();
  5951.   /*NOTREACHED*/
  5952. }
  5953. #endif
  5954.  
  5955. char *
  5956. savestring (input)
  5957.      char *input;
  5958. {
  5959.   int size = strlen (input);
  5960.   char *output = xmalloc (size + 1);
  5961.   strcpy (output, input);
  5962.   return output;
  5963. }
  5964.  
  5965. /* Get the file-mode and data size of the file open on FD
  5966.    and store them in *MODE_POINTER and *SIZE_POINTER.  */
  5967.  
  5968. int
  5969. #if defined( _MSDOS )
  5970. file_size_and_mode (file_name, mode_pointer, size_pointer)
  5971.      char *file_name;
  5972. #else
  5973. file_size_and_mode (fd, mode_pointer, size_pointer)
  5974.      int fd;
  5975. #endif
  5976.      int *mode_pointer;
  5977.      long int *size_pointer;
  5978. {
  5979.   struct stat sbuf;
  5980.  
  5981. #if defined( _MSDOS )
  5982.   if (stat (file_name, &sbuf) < 0) return (-1);
  5983. #else
  5984.   if (fstat (fd, &sbuf) < 0) return (-1);
  5985. #endif
  5986.   if (mode_pointer) *mode_pointer = sbuf.st_mode;
  5987.   if (size_pointer) *size_pointer = sbuf.st_size;
  5988.   return 0;
  5989. }
  5990.  
  5991. #ifdef    VMS
  5992.  
  5993. /* Under VMS we need to fix up the "include" specification
  5994.    filename so that everything following the 1st slash is
  5995.    changed into its correct VMS file specification. */
  5996.  
  5997. hack_vms_include_specification (fname)
  5998.      char *fname;
  5999. {
  6000.   register char *cp, *cp1, *cp2;
  6001.   char Local[512];
  6002. #if ! defined( NeXT )
  6003.   /* the next string.h file already defines index and rindex */
  6004.   extern char *index (), *rindex ();
  6005. #endif
  6006.  
  6007.   /* Ignore leading "./"s */
  6008.   while (fname[0] == '.' && fname[1] == '/')
  6009.     strcpy (fname, fname+2);
  6010.   /* Look for the boundary between the VMS and UNIX filespecs */
  6011.   cp = rindex (fname, ']');    /* Look for end of dirspec. */
  6012.   if (cp == 0) cp == rindex (fname, '>'); /* ... Ditto            */
  6013.   if (cp == 0) cp == rindex (fname, ':'); /* Look for end of devspec. */
  6014.   if (cp) {
  6015.     cp++;
  6016.   } else {
  6017.     cp = index (fname, '/');    /* Look for the "/" */
  6018.   }
  6019.   /* See if we found that 1st slash */
  6020.   if (cp == 0) return;        /* Nothing to do!!! */
  6021.   if (*cp != '/') return;    /* Nothing to do!!! */
  6022.   /* Point to the UNIX filename part (which needs to be fixed!) */
  6023.   cp1 = cp+1;
  6024.   /* If the directory spec is not rooted, we can just copy
  6025.      the UNIX filename part and we are done */
  6026.   if (((cp - fname) > 2)
  6027.       && ((cp[-1] == ']') || (cp[-1] == '>'))
  6028.       && (cp[-2] != '.')) {
  6029.     strcpy (cp, cp1);
  6030.     return;
  6031.   }
  6032.   /* If there are no other slashes then the filename will be
  6033.      in the "root" directory.  Otherwise, we need to add
  6034.      directory specifications. */
  6035.   if (index (cp1, '/') == 0) {
  6036.     /* Just add "[000000]" as the directory string */
  6037.     strcpy (Local, "[000000]");
  6038.     cp2 = Local + strlen (Local);
  6039.   } else {
  6040.     /* Open the directory specification */
  6041.     cp2 = Local;
  6042.     *cp2++ = '[';
  6043.     /* As long as there are still subdirectories to add, do them. */
  6044.     while (index (cp1, '/') != 0) {
  6045.       /* If this token is "." we can ignore it */
  6046.       if ((cp1[0] == '.') && (cp1[1] == '/')) {
  6047.     cp1 += 2;
  6048.     continue;
  6049.       }
  6050.       /* Add a subdirectory spec. */
  6051.       if (cp2 != Local+1) *cp2++ = '.';
  6052.       /* If this is ".." then the spec becomes "-" */
  6053.       if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
  6054.     /* Add "-" and skip the ".." */
  6055.     *cp2++ = '-';
  6056.     cp1 += 3;
  6057.     continue;
  6058.       }
  6059.       /* Copy the subdirectory */
  6060.       while (*cp1 != '/') *cp2++= *cp1++;
  6061.       cp1++;            /* Skip the "/" */
  6062.     }
  6063.     /* Close the directory specification */
  6064.     *cp2++ = ']';
  6065.   }
  6066.   /* Now add the filename */
  6067.   while (*cp1) *cp2++ = *cp1++;
  6068.   *cp2 = 0;
  6069.   /* Now append it to the original VMS spec. */
  6070.   strcpy (cp, Local);
  6071.   return;
  6072. }
  6073. #endif    /* VMS */
  6074.  
  6075. #ifdef    VMS
  6076.  
  6077. /* These are the read/write replacement routines for
  6078.    VAX-11 "C".  They make read/write behave enough
  6079.    like their UNIX counterparts that CCCP will work */
  6080.  
  6081. int
  6082. read (fd, buf, size)
  6083.      int fd;
  6084.      char *buf;
  6085.      int size;
  6086. {
  6087. #undef    read    /* Get back the REAL read routine */
  6088.   register int i;
  6089.   register int total = 0;
  6090.  
  6091.   /* Read until the buffer is exhausted */
  6092.   while (size > 0) {
  6093.     /* Limit each read to 32KB */
  6094.     i = (size > (32*1024)) ? (32*1024) : size;
  6095.     i = read (fd, buf, i);
  6096.     if (i <= 0) {
  6097.       if (i == 0) return (total);
  6098.       return(i);
  6099.     }
  6100.     /* Account for this read */
  6101.     total += i;
  6102.     buf += i;
  6103.     size -= i;
  6104.   }
  6105.   return (total);
  6106. }
  6107.  
  6108. int
  6109. write (fd, buf, size)
  6110.      int fd;
  6111.      char *buf;
  6112.      int size;
  6113. {
  6114. #undef    write    /* Get back the REAL write routine */
  6115.   int i;
  6116.   int j;
  6117.  
  6118.   /* Limit individual writes to 32Kb */
  6119.   i = size;
  6120.   while (i > 0) {
  6121.     j = (i > (32*1024)) ? (32*1024) : i;
  6122.     if (write (fd, buf, j) < 0) return (-1);
  6123.     /* Account for the data written */
  6124.     buf += j;
  6125.     i -= j;
  6126.   }
  6127.   return (size);
  6128. }
  6129.  
  6130. #endif /* VMS */
  6131.